diff --git a/TODO b/TODO
index d070b046ff..ad169165c2 100644
--- a/TODO
+++ b/TODO
@@ -202,11 +202,7 @@ o Task/Scheduler (sched/)
 
                For example, having cancellation points hidden inside of the
                OS can cause non-cancellation point interfaces to behave
-               strangely.  There was a change recently in pthread_cond_wait()
-               and pthread_cond_timedwait() recently to effectively disable
-               the cancellation point behavior of sem_wait().  This was
-               accomplished with two functions:  pthread_disable_cancel()
-               and pthread_enable_cancel()
+               strangely.
 
                Here is another issue:  Internal OS functions should not set
                errno and should never have to look at the errno value to
@@ -217,7 +213,7 @@ o Task/Scheduler (sched/)
 
                Both of these could be fixed if there were special internal
                versions these functions.  For example, there could be a an
-               nx_sem_wait() that does all of the same things as sem_wait()
+               nxsem_wait() that does all of the same things as sem_wait()
                was does not create a cancellation point and does not set
                the errno value on failures.
 
@@ -227,20 +223,13 @@ o Task/Scheduler (sched/)
                and that sets the errno value on failures.
 
                Changes like that could clean up some of this internal
-               craziness.  The condition variable change described above is
-               really a "bandaid" to handle the case that sem_wait() is a
-               cancellation point.  Also will need to revisit previous changes
-               like:
+               craziness.
 
-                 commit b4747286b19d3b15193b2a5e8a0fe48fa0a8638c
-                 Author: Juha Niskanen (Haltian) <juha.niskanen@haltian.com>
-                 Date:   Tue Apr 11 11:03:25 2017 -0600
-
-                     Add logic to disable cancellation points within the OS.
-                     This is useful when an internal OS function that is NOT
-                     a cancellation point calls an OS function which is a
-                     cancellation point.  In that case, irrecoverable states
-                     may occur if the cancellation is within the OS.
+               UPDATE:
+               2017-1003:  This change has been completed for the case of
+                 semaphores used int he OS.  Still need to checkout signals
+                 and messages queues that are also used in the OS.  Also
+                 backed out commit b4747286b19d3b15193b2a5e8a0fe48fa0a8638c.
 
   Status:      Open
   Priority:    Low.  Things are working OK the way they are.  But the design
diff --git a/arch/arm/src/efm32/efm32_dma.c b/arch/arm/src/efm32/efm32_dma.c
index 45fd125063..ef97e08d6c 100644
--- a/arch/arm/src/efm32/efm32_dma.c
+++ b/arch/arm/src/efm32/efm32_dma.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/efm32/efm32_dma.c
  *
- *   Copyright (C) 2014 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -336,6 +336,7 @@ DMA_HANDLE efm32_dmachannel(void)
   struct dma_channel_s *dmach;
   unsigned int chndx;
   uint32_t bit;
+  int ret;
 
   /* Take a count from from the channel counting semaphore.  We may block
    * if there are no free channels.  When we get the count, then we can
@@ -343,21 +344,35 @@ DMA_HANDLE efm32_dmachannel(void)
    * reserved for us.
    */
 
-  while (sem_wait(&g_dmac.chansem) < 0)
+  do
     {
-      /* sem_wait should fail only if it is awakened by a a signal */
+      /* Take the semaphore (perhaps waiting) */
 
-      DEBUGASSERT(errno == EINTR);
+      ret = nxsem_wait(&g_dmac.chansem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   /* Get exclusive access to the DMA channel list */
 
-  while (sem_wait(&g_dmac.exclsem) < 0)
+  do
     {
-      /* sem_wait should fail only if it is awakened by a a signal */
+      /* Take the semaphore (perhaps waiting) */
 
-      DEBUGASSERT(errno == EINTR);
+      ret = nxsem_wait(&g_dmac.exclsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   /* Search for an available DMA channel */
 
diff --git a/arch/arm/src/efm32/efm32_i2c.c b/arch/arm/src/efm32/efm32_i2c.c
index 38129b40ab..40c4bcf9d0 100644
--- a/arch/arm/src/efm32/efm32_i2c.c
+++ b/arch/arm/src/efm32/efm32_i2c.c
@@ -5,7 +5,7 @@
  *   Copyright (C) 2015 Pierre-noel Bouteville . All rights reserved.
  *   Authors: Pierre-noel Bouteville <pnb990@gmail.com>
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -480,10 +480,21 @@ static const char *efm32_i2c_state_str(int i2c_state)
 
 static inline void efm32_i2c_sem_wait(FAR struct efm32_i2c_priv_s *priv)
 {
-  while (sem_wait(&priv->sem_excl) != OK)
+  int ret;
+
+  do
     {
-      ASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->sem_excl);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/efm32/efm32_spi.c b/arch/arm/src/efm32/efm32_spi.c
index 8f238569ff..f16d196e64 100644
--- a/arch/arm/src/efm32/efm32_spi.c
+++ b/arch/arm/src/efm32/efm32_spi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arm/arm/src/efm32/efm32_spi.c
  *
- *   Copyright (C) 2014, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014, 2016-2017 Gregory Nutt. All rights reserved.
  *   Copyright (C) 2014 Bouteville Pierre-Noel. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *            Bouteville Pierre-Noel <pnb990@gmail.com>
@@ -437,18 +437,24 @@ static void spi_dma_timeout(int argc, uint32_t arg1, ...)
 static void spi_dmarxwait(struct efm32_spidev_s *priv)
 {
   irqstate_t flags;
+  int ret;
 
   /* Take the semaphore (perhaps waiting). */
 
   flags = enter_critical_section();
-  while (sem_wait(&priv->rxdmasem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->rxdmasem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      DEBUGASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   /* Cancel the timeout only if both the RX and TX transfers have completed */
 
@@ -474,18 +480,24 @@ static void spi_dmarxwait(struct efm32_spidev_s *priv)
 static void spi_dmatxwait(struct efm32_spidev_s *priv)
 {
   irqstate_t flags;
+  int ret;
 
   /* Take the semaphore (perhaps waiting). */
 
   flags = enter_critical_section();
-  while (sem_wait(&priv->txdmasem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->txdmasem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      DEBUGASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   /* Cancel the timeout only if both the RX and TX transfers have completed */
 
@@ -748,21 +760,25 @@ static int spi_lock(struct spi_dev_s *dev, bool lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
+          ret = nxsem_wait(&priv->exclsem);
+
           /* The only case that an error should occur here is if the wait
            * was awakened by a signal.
            */
 
-          DEBUGASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/efm32/efm32_usbhost.c b/arch/arm/src/efm32/efm32_usbhost.c
index 0fe5f8dcfa..7d9cb4de29 100644
--- a/arch/arm/src/efm32/efm32_usbhost.c
+++ b/arch/arm/src/efm32/efm32_usbhost.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/efm32/efm32_usbhost.c
  *
- *   Copyright (C) 2014-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -718,16 +718,21 @@ static inline void efm32_modifyreg(uint32_t addr, uint32_t clrbits, uint32_t set
 
 static void efm32_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
@@ -1181,13 +1186,13 @@ static int efm32_chan_wait(FAR struct efm32_usbhost_s *priv,
        * wait here.
        */
 
-      ret = sem_wait(&chan->waitsem);
+      ret = nxsem_wait(&chan->waitsem);
 
-      /* sem_wait should succeed.  But it is possible that we could be
+      /* nxsem_wait should succeed.  But it is possible that we could be
        * awakened by a signal too.
        */
 
-      DEBUGASSERT(ret == OK || get_errno() == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
   while (chan->waiter);
 
diff --git a/arch/arm/src/imx1/imx_spi.c b/arch/arm/src/imx1/imx_spi.c
index c3097745a0..92208b78be 100644
--- a/arch/arm/src/imx1/imx_spi.c
+++ b/arch/arm/src/imx1/imx_spi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/imx1/imx_spi.c
  *
- *   Copyright (C) 2009-2010, 2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2009-2010, 2013, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -562,9 +562,9 @@ static int spi_transfer(struct imx_spidev_s *priv, const void *txbuffer,
     {
       /* Wait to be signaled from the interrupt handler */
 
-      ret = sem_wait(&priv->waitsem);
+      ret = nxsem_wait(&priv->waitsem);
     }
-  while (ret < 0 && errno == EINTR);
+  while (ret < 0 && ret == -EINTR);
 
 #else
   /* Perform the transfer using polling logic.  This will totally
@@ -709,26 +709,26 @@ static int spi_interrupt(int irq, void *context, FAR void *arg, FAR void *arg)
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   struct imx_spidev_s *priv = (struct imx_spidev_s *)dev;
+  int ret;
 
   if (lock)
     {
-      /* Take the semaphore (perhaps waiting) */
-
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait
-           * was awakened by a signal.
-           */
+          /* Take the semaphore (perhaps waiting) */
 
-          DEBUGASSERT(errno == EINTR);
+          ret = nxsem_wait(&priv->exclsem);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/imx6/imx_ecspi.c b/arch/arm/src/imx6/imx_ecspi.c
index ad78589c77..dc586cda45 100644
--- a/arch/arm/src/imx6/imx_ecspi.c
+++ b/arch/arm/src/imx6/imx_ecspi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/imx6/imx_ecspi.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Derives from the i.MX1 CSPI driver:
@@ -687,9 +687,9 @@ static int spi_transfer(struct imx_spidev_s *priv, const void *txbuffer,
     {
       /* Wait to be signaled from the interrupt handler */
 
-      ret = sem_wait(&priv->waitsem);
+      ret = nxsem_wait(&priv->waitsem);
     }
-  while (ret < 0 && errno == EINTR);
+  while (ret < 0 && ret == -EINTR);
 
 #else
   /* Perform the transfer using polling logic.  This will totally
@@ -794,26 +794,26 @@ static int spi_interrupt(int irq, void *context, FAR void *arg)
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   struct imx_spidev_s *priv = (struct imx_spidev_s *)dev;
+  int ret;
 
   if (lock)
     {
-      /* Take the semaphore (perhaps waiting) */
-
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait
-           * was awakened by a signal.
-           */
+          /* Take the semaphore (perhaps waiting) */
 
-          DEBUGASSERT(errno == EINTR);
+          ret = nxsem_wait(&priv->exclsem);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/imx6/imx_serial.c b/arch/arm/src/imx6/imx_serial.c
index 0e47e2387c..8ec37f97e4 100644
--- a/arch/arm/src/imx6/imx_serial.c
+++ b/arch/arm/src/imx6/imx_serial.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/imx6/imx_serial.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -963,10 +963,10 @@ int up_putc(int ch)
 
   if (!up_interrupt_context() && g_os_initstate >= OSINIT_HARDWARE)
     {
-      ret = sem_wait(&g_putc_lock);
+      ret = nxsem_wait(&g_putc_lock);
       if (ret < 0)
         {
-          return ERROR;
+          return ret;
         }
 
       locked = true;
diff --git a/arch/arm/src/kinetis/kinetis_i2c.c b/arch/arm/src/kinetis/kinetis_i2c.c
index 8f15bbe5b3..3e40998650 100644
--- a/arch/arm/src/kinetis/kinetis_i2c.c
+++ b/arch/arm/src/kinetis/kinetis_i2c.c
@@ -350,10 +350,21 @@ static inline void kinetis_i2c_sem_destroy(FAR struct kinetis_i2cdev_s *priv)
 
 static inline void kinetis_i2c_sem_wait(FAR struct kinetis_i2cdev_s *priv)
 {
-  while (sem_wait(&priv->mutex) != 0)
+  int ret;
+
+  do
     {
-      DEBUGASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->mutex);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /************************************************************************************
@@ -379,7 +390,7 @@ static inline void kinetis_i2c_sem_post(struct kinetis_i2cdev_s *priv)
 
 static inline void kinetis_i2c_wait(struct kinetis_i2cdev_s *priv)
 {
-  sem_wait(&priv->wait);
+  (void)nxsem_wait(&priv->wait);
 }
 
 /************************************************************************************
diff --git a/arch/arm/src/kinetis/kinetis_sdhc.c b/arch/arm/src/kinetis/kinetis_sdhc.c
index 0c9f4a8adf..1a3a0b53b7 100644
--- a/arch/arm/src/kinetis/kinetis_sdhc.c
+++ b/arch/arm/src/kinetis/kinetis_sdhc.c
@@ -432,16 +432,21 @@ static struct kinetis_sdhcregs_s g_sampleregs[DEBUG_NSAMPLES];
 
 static void kinetis_takesem(struct kinetis_dev_s *priv)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&priv->waitsem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->waitsem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/kinetis/kinetis_spi.c b/arch/arm/src/kinetis/kinetis_spi.c
index 1a5662f18f..1d1fdfabe0 100644
--- a/arch/arm/src/kinetis/kinetis_spi.c
+++ b/arch/arm/src/kinetis/kinetis_spi.c
@@ -583,26 +583,31 @@ void inline spi_run(FAR struct kinetis_spidev_s *priv, bool enable)
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct kinetis_spidev_s *priv = (FAR struct kinetis_spidev_s *)dev;
+  int ret;
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /************************************************************************************
diff --git a/arch/arm/src/kl/kl_spi.c b/arch/arm/src/kl/kl_spi.c
index 323bc5d348..8778a17007 100644
--- a/arch/arm/src/kl/kl_spi.c
+++ b/arch/arm/src/kl/kl_spi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/kl/kl_spi.c
  *
- *   Copyright (C) 2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -235,25 +235,31 @@ static inline void spi_putreg(FAR struct kl_spidev_s *priv, uint8_t offset,
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct kl_spidev_s *priv = (FAR struct kl_spidev_s *)dev;
+  int ret;
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
-  return OK;
+
+  return ret;
 }
 
 /************************************************************************************
diff --git a/arch/arm/src/lc823450/lc823450_adc.c b/arch/arm/src/lc823450/lc823450_adc.c
index 53649d22dc..8ff89be6ae 100644
--- a/arch/arm/src/lc823450/lc823450_adc.c
+++ b/arch/arm/src/lc823450/lc823450_adc.c
@@ -226,7 +226,9 @@ static void lc823450_adc_start(FAR struct lc823450_adc_inst_s *inst)
   uint8_t i;
   uint32_t div;
 
-#ifdef CONFIG_ADC_POLLED
+#ifndef CONFIG_ADC_POLLED
+  int ret;
+#else
   irqstate_t flags;
 
   flags = enter_critical_section();
@@ -261,10 +263,19 @@ static void lc823450_adc_start(FAR struct lc823450_adc_inst_s *inst)
   while ((getreg32(rADCSTS) & rADCSTS_fADCMPL) == 0)
     ;
 #else
-  while (sem_wait(&inst->sem_isr) != 0)
+  do
     {
-      ASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&inst->sem_isr);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 #endif
 
 #ifdef CONFIG_ADC_POLLED
@@ -282,10 +293,21 @@ static void lc823450_adc_start(FAR struct lc823450_adc_inst_s *inst)
 
 static inline void lc823450_adc_sem_wait(FAR struct lc823450_adc_inst_s *inst)
 {
-  while (sem_wait(&inst->sem_excl) != 0)
+  int ret;
+
+  do
     {
-      ASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&inst->sem_excl);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/lc823450/lc823450_i2c.c b/arch/arm/src/lc823450/lc823450_i2c.c
index 5f2139f1c1..5c1569388b 100644
--- a/arch/arm/src/lc823450/lc823450_i2c.c
+++ b/arch/arm/src/lc823450/lc823450_i2c.c
@@ -260,10 +260,21 @@ static struct lc823450_i2c_priv_s lc823450_i2c1_priv =
 
 static inline void lc823450_i2c_sem_wait(FAR struct lc823450_i2c_priv_s *priv)
 {
-  while (sem_wait(&priv->sem_excl) != 0)
+  int ret;
+
+  do
     {
-      ASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->sem_excl);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/lc823450/lc823450_mtd.c b/arch/arm/src/lc823450/lc823450_mtd.c
index ce8a7fee52..982a1fed63 100644
--- a/arch/arm/src/lc823450/lc823450_mtd.c
+++ b/arch/arm/src/lc823450/lc823450_mtd.c
@@ -142,10 +142,21 @@ static struct lc823450_partinfo_s partinfo[LC823450_NPARTS] =
 
 static void mtd_semtake(FAR sem_t *sem)
 {
-  while (sem_wait(sem) != 0)
+  int ret;
+
+  do
     {
-      ASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/lc823450/lc823450_sdc.c b/arch/arm/src/lc823450/lc823450_sdc.c
index 5f0720db45..b0f0a357e2 100644
--- a/arch/arm/src/lc823450/lc823450_sdc.c
+++ b/arch/arm/src/lc823450/lc823450_sdc.c
@@ -138,10 +138,21 @@ extern SINT_T sddep_write(void *src, void *dst, UI_32 size, SINT_T type,
 
 static void _sdc_semtake(FAR sem_t *sem)
 {
-  while (sem_wait(sem) != 0)
+  int ret;
+
+  do
     {
-      ASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/lc823450/lc823450_sddrv_dep.c b/arch/arm/src/lc823450/lc823450_sddrv_dep.c
index c6170fc855..986b98c28e 100644
--- a/arch/arm/src/lc823450/lc823450_sddrv_dep.c
+++ b/arch/arm/src/lc823450/lc823450_sddrv_dep.c
@@ -131,10 +131,21 @@ static void dma_callback(DMA_HANDLE hdma, void *arg, int result)
 
 static void _sddep_semtake(FAR sem_t *sem)
 {
-  while (sem_wait(sem) != 0)
+  int ret;
+
+  do
     {
-      ASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/lc823450/lc823450_serial.c b/arch/arm/src/lc823450/lc823450_serial.c
index 8f41f17ea7..eba588f38b 100644
--- a/arch/arm/src/lc823450/lc823450_serial.c
+++ b/arch/arm/src/lc823450/lc823450_serial.c
@@ -1204,7 +1204,7 @@ static int up_hs_send(struct uart_dev_s *dev, const char *buf, int buflen)
 
 retry:
 
-  sem_wait(&priv->txdma_wait);
+  nxsem_wait(&priv->txdma_wait);
 
   /* If buflen <= FIFO space, write it by PIO. */
 
diff --git a/arch/arm/src/lc823450/lc823450_spi.c b/arch/arm/src/lc823450/lc823450_spi.c
index dd741de584..038351d79a 100644
--- a/arch/arm/src/lc823450/lc823450_spi.c
+++ b/arch/arm/src/lc823450/lc823450_spi.c
@@ -149,26 +149,31 @@ static struct lc823450_spidev_s g_spidev =
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct lc823450_spidev_s *priv = (FAR struct lc823450_spidev_s *)dev;
+  int ret;
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+         ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait was
+           * awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 #endif
 
@@ -409,7 +414,7 @@ static void spi_sndblock(FAR struct spi_dev_s *dev, FAR const void *buffer,
 
       modifyreg32(LC823450_SPI_SMD, 0, SPI_SMD_WTR);
 
-      while (sem_wait(&priv->dma_wait) != 0);
+      while (nxsem_wait(&priv->dma_wait) < 0);
       nwords -= len;
       buffer += len;
     }
diff --git a/arch/arm/src/lc823450/lc823450_timerisr.c b/arch/arm/src/lc823450/lc823450_timerisr.c
index c962fe2401..1357219b26 100644
--- a/arch/arm/src/lc823450/lc823450_timerisr.c
+++ b/arch/arm/src/lc823450/lc823450_timerisr.c
@@ -391,7 +391,7 @@ int up_hrttimer_usleep(unsigned int usec)
   hrt.usec = usec;
 
   hrt_usleep_add(&hrt);
-  sem_wait(&hrt.sem);
+  nxsem_wait(&hrt.sem);
 
   return 0;
 }
diff --git a/arch/arm/src/lc823450/lc823450_usbdev.c b/arch/arm/src/lc823450/lc823450_usbdev.c
index 8120acac24..b348c1ff82 100644
--- a/arch/arm/src/lc823450/lc823450_usbdev.c
+++ b/arch/arm/src/lc823450/lc823450_usbdev.c
@@ -1780,7 +1780,7 @@ int usbdev_msc_epwrite(void *buf, int len)
            USB_DMAC_START,
            USB_DMAC1);
 
-  (void)sem_wait(&dma_wait);
+  (void)nxsem_wait(&dma_wait);
   return 0;
 }
 
@@ -1884,7 +1884,7 @@ int usbdev_msc_epread(void *buf, int len)
            CONFIG_USBMSC_EPBULKOUT  << USB_DMAC_DMAEP_SHIFT |
            USB_DMAC_START,
            USB_DMAC1);
-           (void)sem_wait(&dma_wait);
+           (void)nxsem_wait(&dma_wait);
 
   return 0;
 }
diff --git a/arch/arm/src/lpc11xx/lpc11_i2c.c b/arch/arm/src/lpc11xx/lpc11_i2c.c
index 145aafcb5c..1c94939da9 100644
--- a/arch/arm/src/lpc11xx/lpc11_i2c.c
+++ b/arch/arm/src/lpc11xx/lpc11_i2c.c
@@ -216,7 +216,7 @@ static int lpc11_i2c_start(struct lpc11_i2cdev_s *priv)
   putreg32(I2C_CONSET_STA, priv->base + LPC11_I2C_CONSET_OFFSET);
 
   wd_start(priv->timeout, I2C_TIMEOUT, lpc11_i2c_timeout, 1, (uint32_t)priv);
-  sem_wait(&priv->wait);
+  nxsem_wait(&priv->wait);
 
   wd_cancel(priv->timeout);
 
@@ -278,7 +278,7 @@ static int lpc11_i2c_transfer(FAR struct i2c_master_s *dev,
 
   /* Get exclusive access to the I2C bus */
 
-  sem_wait(&priv->mutex);
+  nxsem_wait(&priv->mutex);
 
   /* Set up for the transfer */
 
diff --git a/arch/arm/src/lpc11xx/lpc11_spi.c b/arch/arm/src/lpc11xx/lpc11_spi.c
index e457d408f0..363cd6466a 100644
--- a/arch/arm/src/lpc11xx/lpc11_spi.c
+++ b/arch/arm/src/lpc11xx/lpc11_spi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/lpc11xx/lpc11_spi.c
  *
- *   Copyright (C) 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -186,25 +186,31 @@ static struct lpc11_spidev_s g_spidev =
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct lpc11_spidev_s *priv = (FAR struct lpc11_spidev_s *)dev;
+  int ret;
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
+          ret = nxsem_wait(&priv->exclsem);
+
           /* The only case that an error should occur here is if the wait
            * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = 0
     }
-  return OK;
+
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/lpc11xx/lpc11_ssp.c b/arch/arm/src/lpc11xx/lpc11_ssp.c
index 7bb6343349..32cccc29f3 100644
--- a/arch/arm/src/lpc11xx/lpc11_ssp.c
+++ b/arch/arm/src/lpc11xx/lpc11_ssp.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/lpc11xx/lpc11_ssp.c
  *
- *   Copyright (C) 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -334,25 +334,31 @@ static inline void ssp_putreg(FAR struct lpc11_sspdev_s *priv,
 static int ssp_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct lpc11_sspdev_s *priv = (FAR struct lpc11_sspdev_s *)dev;
+  int ret
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
+          ret = nxsem_wait(&priv->exclsem);
+
           /* The only case that an error should occur here is if the wait
            * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
-  return OK;
+
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/lpc17xx/lpc17_gpdma.c b/arch/arm/src/lpc17xx/lpc17_gpdma.c
index c5eacf660d..7825f2ce0d 100644
--- a/arch/arm/src/lpc17xx/lpc17_gpdma.c
+++ b/arch/arm/src/lpc17xx/lpc17_gpdma.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/lpc17xx/lpc17_gpdma.c
  *
- *   Copyright (C) 2010, 2014, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2010, 2014, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -395,10 +395,10 @@ DMA_HANDLE lpc17_dmachannel(void)
 
   do
     {
-      ret = sem_wait(&g_gpdma.exclsem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(&g_gpdma.exclsem);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 
   /* Find an available DMA channel */
 
diff --git a/arch/arm/src/lpc17xx/lpc17_i2c.c b/arch/arm/src/lpc17xx/lpc17_i2c.c
index fab01a79e8..579e943336 100644
--- a/arch/arm/src/lpc17xx/lpc17_i2c.c
+++ b/arch/arm/src/lpc17xx/lpc17_i2c.c
@@ -216,7 +216,7 @@ static int lpc17_i2c_start(struct lpc17_i2cdev_s *priv)
   putreg32(I2C_CONSET_STA, priv->base + LPC17_I2C_CONSET_OFFSET);
 
   wd_start(priv->timeout, I2C_TIMEOUT, lpc17_i2c_timeout, 1, (uint32_t)priv);
-  sem_wait(&priv->wait);
+  nxsem_wait(&priv->wait);
 
   wd_cancel(priv->timeout);
 
@@ -278,7 +278,7 @@ static int lpc17_i2c_transfer(FAR struct i2c_master_s *dev,
 
   /* Get exclusive access to the I2C bus */
 
-  sem_wait(&priv->mutex);
+  nxsem_wait(&priv->mutex);
 
   /* Set up for the transfer */
 
diff --git a/arch/arm/src/lpc17xx/lpc17_sdcard.c b/arch/arm/src/lpc17xx/lpc17_sdcard.c
index 85552b28a8..3d7fdffe70 100644
--- a/arch/arm/src/lpc17xx/lpc17_sdcard.c
+++ b/arch/arm/src/lpc17xx/lpc17_sdcard.c
@@ -485,16 +485,21 @@ static struct lpc17_sampleregs_s g_sampleregs[DEBUG_NSAMPLES];
 
 static void lpc17_takesem(struct lpc17_dev_s *priv)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&priv->waitsem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->waitsem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/lpc17xx/lpc17_spi.c b/arch/arm/src/lpc17xx/lpc17_spi.c
index 97ddcf3482..60deac4fb5 100644
--- a/arch/arm/src/lpc17xx/lpc17_spi.c
+++ b/arch/arm/src/lpc17xx/lpc17_spi.c
@@ -1,7 +1,8 @@
 /****************************************************************************
  * arch/arm/src/lpc17xx/lpc17_spi.c
  *
- *   Copyright (C) 2010, 2012-2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2010, 2012-2013, 2016-2017 Gregory Nutt. All rights
+ *     reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -182,25 +183,31 @@ static struct lpc17_spidev_s g_spidev =
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct lpc17_spidev_s *priv = (FAR struct lpc17_spidev_s *)dev;
+  int ret;
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
-  return OK;
+
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/lpc17xx/lpc17_ssp.c b/arch/arm/src/lpc17xx/lpc17_ssp.c
index ba0922ef85..98220105dc 100644
--- a/arch/arm/src/lpc17xx/lpc17_ssp.c
+++ b/arch/arm/src/lpc17xx/lpc17_ssp.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/lpc17xx/lpc17_ssp.c
  *
- *   Copyright (C) 2010-2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2010-2013, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -330,25 +330,31 @@ static inline void ssp_putreg(FAR struct lpc17_sspdev_s *priv, uint8_t offset, u
 static int ssp_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct lpc17_sspdev_s *priv = (FAR struct lpc17_sspdev_s *)dev;
+  int ret;
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
-  return OK;
+
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/lpc17xx/lpc17_usbhost.c b/arch/arm/src/lpc17xx/lpc17_usbhost.c
index cebbdbc23b..9a613faf80 100644
--- a/arch/arm/src/lpc17xx/lpc17_usbhost.c
+++ b/arch/arm/src/lpc17xx/lpc17_usbhost.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/lpc17xx/lpc17_usbhost.c
  *
- *   Copyright (C) 2010-2012, 2014-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2010-2012, 2014-2017 Gregory Nutt. All rights reserved.
  *   Authors: Rafael Noronha <rafael@pdsolucoes.com.br>
  *            Gregory Nutt <gnutt@nuttx.org>
  *
@@ -583,16 +583,21 @@ static void lpc17_putreg(uint32_t val, uint32_t addr)
 
 static void lpc17_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/lpc2378/lpc23xx_i2c.c b/arch/arm/src/lpc2378/lpc23xx_i2c.c
index 4f64a167e2..00d44687ea 100644
--- a/arch/arm/src/lpc2378/lpc23xx_i2c.c
+++ b/arch/arm/src/lpc2378/lpc23xx_i2c.c
@@ -221,7 +221,7 @@ static int lpc2378_i2c_start(struct lpc2378_i2cdev_s *priv)
   putreg32(I2C_CONSET_STA, priv->base + I2C_CONSET_OFFSET);
 
   wd_start(priv->timeout, I2C_TIMEOUT, lpc2378_i2c_timeout, 1, (uint32_t)priv);
-  sem_wait(&priv->wait);
+  nxsem_wait(&priv->wait);
 
   wd_cancel(priv->timeout);
 
@@ -404,7 +404,7 @@ static int lpc2378_i2c_transfer(FAR struct i2c_master_s *dev,
 
   /* Get exclusive access to the I2C bus */
 
-  sem_wait(&priv->mutex);
+  nxsem_wait(&priv->mutex);
 
   /* Set up for the transfer */
 
diff --git a/arch/arm/src/lpc2378/lpc23xx_spi.c b/arch/arm/src/lpc2378/lpc23xx_spi.c
index 94a635fae1..bc7f46cf07 100644
--- a/arch/arm/src/lpc2378/lpc23xx_spi.c
+++ b/arch/arm/src/lpc2378/lpc23xx_spi.c
@@ -6,7 +6,7 @@
  *
  * Derived from  arch/arm/src/lpc17xx/lpc17_spi.c
  *
- *   Copyright (C) 2010, 2012, 2014, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2010, 2012, 2014, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -189,26 +189,31 @@ static struct lpc23xx_spidev_s g_spidev =
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct lpc23xx_spidev_s *priv = (FAR struct lpc23xx_spidev_s *)dev;
+  int ret;
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/lpc31xx/lpc31_ehci.c b/arch/arm/src/lpc31xx/lpc31_ehci.c
index 58c7c808fc..b816bc11be 100644
--- a/arch/arm/src/lpc31xx/lpc31_ehci.c
+++ b/arch/arm/src/lpc31xx/lpc31_ehci.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/lpc31xx/lpc31_ehci.c
  *
- *   Copyright (C) 2013-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -1013,16 +1013,21 @@ static int ehci_wait_usbsts(uint32_t maskbits, uint32_t donebits,
 
 static void lpc31_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/lpc31xx/lpc31_i2c.c b/arch/arm/src/lpc31xx/lpc31_i2c.c
index 5ff3bb8bf6..c65d55c471 100644
--- a/arch/arm/src/lpc31xx/lpc31_i2c.c
+++ b/arch/arm/src/lpc31xx/lpc31_i2c.c
@@ -467,7 +467,7 @@ static int i2c_transfer(FAR struct i2c_master_s *dev, FAR struct i2c_msg_s *msgs
 
   /* Get exclusive access to the I2C bus */
 
-  sem_wait(&priv->mutex);
+  nxsem_wait(&priv->mutex);
   flags = enter_critical_section();
 
   /* Set up for the transfer */
@@ -496,7 +496,7 @@ static int i2c_transfer(FAR struct i2c_master_s *dev, FAR struct i2c_msg_s *msgs
 
   while (priv->state != I2C_STATE_DONE)
     {
-      sem_wait(&priv->wait);
+      nxsem_wait(&priv->wait);
     }
 
   wd_cancel(priv->timeout);
diff --git a/arch/arm/src/lpc31xx/lpc31_spi.c b/arch/arm/src/lpc31xx/lpc31_spi.c
index 5392b20b8d..d0275a502d 100644
--- a/arch/arm/src/lpc31xx/lpc31_spi.c
+++ b/arch/arm/src/lpc31xx/lpc31_spi.c
@@ -1,7 +1,7 @@
 /************************************************************************************
  * arm/arm/src/lpc31xx/lpc31_spi.c
  *
- *   Copyright (C) 2009-2010, 2012, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2009-2010, 2012, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: David Hewson, deriving in part from other SPI drivers originally by
  *           Gregory Nutt <gnutt@nuttx.org>
  *
@@ -443,25 +443,31 @@ static inline void spi_writeword(FAR struct lpc31_spidev_s *priv, uint16_t word)
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct lpc31_spidev_s *priv = (FAR struct lpc31_spidev_s *)dev;
+  int ret;
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
-  return OK;
+
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/lpc43xx/lpc43_ehci.c b/arch/arm/src/lpc43xx/lpc43_ehci.c
index 8e310c73b2..a3b0813d89 100644
--- a/arch/arm/src/lpc43xx/lpc43_ehci.c
+++ b/arch/arm/src/lpc43xx/lpc43_ehci.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/lpc43xx/lpc43_ehci.c
  *
- *   Copyright (C) 2013-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -1004,16 +1004,21 @@ static int ehci_wait_usbsts(uint32_t maskbits, uint32_t donebits,
 
 static void lpc43_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/lpc43xx/lpc43_gpdma.c b/arch/arm/src/lpc43xx/lpc43_gpdma.c
index e4dc02b74e..d2c0f3bace 100644
--- a/arch/arm/src/lpc43xx/lpc43_gpdma.c
+++ b/arch/arm/src/lpc43xx/lpc43_gpdma.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/lpc43xx/lpc43_gpdma.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -396,8 +396,8 @@ DMA_HANDLE lpc43_dmachannel(void)
 
   do
     {
-      ret = sem_wait(&g_gpdma.exclsem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(&g_gpdma.exclsem);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
   while (ret < 0);
 
diff --git a/arch/arm/src/lpc43xx/lpc43_i2c.c b/arch/arm/src/lpc43xx/lpc43_i2c.c
index 1d5237367b..f613470a8f 100644
--- a/arch/arm/src/lpc43xx/lpc43_i2c.c
+++ b/arch/arm/src/lpc43xx/lpc43_i2c.c
@@ -203,7 +203,7 @@ static int lpc43_i2c_start(struct lpc43_i2cdev_s *priv)
   putreg32(I2C_CONSET_STA, priv->base + LPC43_I2C_CONSET_OFFSET);
 
   wd_start(priv->timeout, I2C_TIMEOUT, lpc43_i2c_timeout, 1, (uint32_t)priv);
-  sem_wait(&priv->wait);
+  nxsem_wait(&priv->wait);
 
   wd_cancel(priv->timeout);
   return priv->nmsg;
@@ -385,7 +385,7 @@ static int lpc43_i2c_transfer(FAR struct i2c_master_s *dev,
 
   /* Get exclusive access to the I2C bus */
 
-  sem_wait(&priv->mutex);
+  nxsem_wait(&priv->mutex);
 
   /* Set up for the transfer */
 
diff --git a/arch/arm/src/lpc43xx/lpc43_spi.c b/arch/arm/src/lpc43xx/lpc43_spi.c
index 3489f1f31c..a77996513b 100644
--- a/arch/arm/src/lpc43xx/lpc43_spi.c
+++ b/arch/arm/src/lpc43xx/lpc43_spi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/lpc43xx/lpc43_spi.c
  *
- *   Copyright (C) 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -176,25 +176,31 @@ static struct lpc43_spidev_s g_spidev =
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct lpc43_spidev_s *priv = (FAR struct lpc43_spidev_s *)dev;
+  int ret;
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
-  return OK;
+
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/lpc43xx/lpc43_ssp.c b/arch/arm/src/lpc43xx/lpc43_ssp.c
index c58f5e9ee3..2660b00654 100644
--- a/arch/arm/src/lpc43xx/lpc43_ssp.c
+++ b/arch/arm/src/lpc43xx/lpc43_ssp.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/lpc43xx/lpc43_ssp.c
  *
- *   Copyright (C) 2012, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -272,26 +272,31 @@ static inline void ssp_putreg(FAR struct lpc43_sspdev_s *priv, uint8_t offset, u
 static int ssp_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct lpc43_sspdev_s *priv = (FAR struct lpc43_sspdev_s *)dev;
+  int ret;
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/sam34/sam4cm_tc.c b/arch/arm/src/sam34/sam4cm_tc.c
index 08ba5f8885..79cc61cfdb 100644
--- a/arch/arm/src/sam34/sam4cm_tc.c
+++ b/arch/arm/src/sam34/sam4cm_tc.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/sam34/sam_tc.c
  *
- *   Copyright (C) 2013-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References:
@@ -360,16 +360,21 @@ static const uint8_t g_regoffset[TC_NREGISTERS] =
 
 static void sam_takesem(struct sam_chan_s *chan)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&chan->exclsem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&chan->exclsem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/sam34/sam_aes.c b/arch/arm/src/sam34/sam_aes.c
index f87cfa951c..c974667930 100644
--- a/arch/arm/src/sam34/sam_aes.c
+++ b/arch/arm/src/sam34/sam_aes.c
@@ -88,7 +88,7 @@ static sem_t lock;
 
 static void aes_lock(void)
 {
-  sem_wait(&lock);
+  nxsem_wait(&lock);
 }
 
 static void aes_unlock(void)
diff --git a/arch/arm/src/sam34/sam_dmac.c b/arch/arm/src/sam34/sam_dmac.c
index 5498836529..074e58d2f7 100644
--- a/arch/arm/src/sam34/sam_dmac.c
+++ b/arch/arm/src/sam34/sam_dmac.c
@@ -1,7 +1,8 @@
 /****************************************************************************
  * arch/arm/src/sam34/sam_dmac.c
  *
- *   Copyright (C) 2010, 2013-2014, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2010, 2013-2014, 2016-2017 Gregory Nutt. All rights
+ *     reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -274,16 +275,21 @@ static struct sam_dma_s g_dma[SAM34_NDMACHAN] =
 
 static void sam_takechsem(void)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&g_chsem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&g_chsem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void sam_givechsem(void)
@@ -301,16 +307,21 @@ static inline void sam_givechsem(void)
 
 static void sam_takedsem(void)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&g_dsem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&g_dsem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void sam_givedsem(void)
diff --git a/arch/arm/src/sam34/sam_hsmci.c b/arch/arm/src/sam34/sam_hsmci.c
index 0a15e2a5a4..0ac187982b 100644
--- a/arch/arm/src/sam34/sam_hsmci.c
+++ b/arch/arm/src/sam34/sam_hsmci.c
@@ -591,16 +591,21 @@ static bool                     g_cmdinitialized;
 
 static void sam_takesem(struct sam_dev_s *priv)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&priv->waitsem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->waitsem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/sam34/sam_spi.c b/arch/arm/src/sam34/sam_spi.c
index d06abddc40..0dc57e7a6c 100644
--- a/arch/arm/src/sam34/sam_spi.c
+++ b/arch/arm/src/sam34/sam_spi.c
@@ -1,7 +1,8 @@
 /****************************************************************************
  * arch/arm/src/sam34/sam_spi.c
  *
- *   Copyright (C) 2011, 2013-2014, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011, 2013-2014, 2016-2017 Gregory Nutt. All rights
+ *     reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *            Diego Sanchez <dsanchez@nx-engineering.com>
  *
@@ -876,27 +877,34 @@ static int spi_lock(struct spi_dev_s *dev, bool lock)
 {
   struct sam_spics_s *spics = (struct sam_spics_s *)dev;
   struct sam_spidev_s *spi = spi_device(spics);
+  int ret;
 
   spiinfo("lock=%d\n", lock);
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&spi->spisem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          /* Take the semaphore (perhaps waiting) */
+
+          ret = nxsem_wait(&spi->spisem);
+
+          /* The only case that an error should occur here is if the wait was
+           * awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&spi->spisem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
@@ -1589,26 +1597,20 @@ static void spi_exchange(struct spi_dev_s *dev, const void *txbuffer,
 
       /* Wait for the DMA complete */
 
-      ret = sem_wait(&spics->dmawait);
+      ret = nxsem_wait(&spics->dmawait);
 
       /* Cancel the watchdog timeout */
 
       (void)wd_cancel(spics->dmadog);
 
-      /* Check if we were awakened by an error of some kind */
+      /* Check if we were awakened by an error of some kind.  EINTR is not a
+       * failure.  It simply means that the wait was awakened by a signal.
+       */
 
-      if (ret < 0)
+      if (ret < 0 && ret != -EINTR)
         {
-          /* EINTR is not a failure.  That simply means that the wait
-           * was awakened by a signal.
-           */
-
-          int errorcode = errno;
-          if (errorcode != EINTR)
-            {
-              DEBUGPANIC();
-              return;
-            }
+          DEBUGPANIC();
+          return;
         }
 
       /* Not that we might be awakened before the wait is over due to
diff --git a/arch/arm/src/sam34/sam_twi.c b/arch/arm/src/sam34/sam_twi.c
index 1113144258..18b510cbcb 100644
--- a/arch/arm/src/sam34/sam_twi.c
+++ b/arch/arm/src/sam34/sam_twi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/sam34/sam_twi.c
  *
- *   Copyright (C) 2013, 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013, 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References:
@@ -225,16 +225,21 @@ static const struct i2c_ops_s g_twiops =
 
 static void twi_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/sama5/sam_adc.c b/arch/arm/src/sama5/sam_adc.c
index 056abd443e..c61f44a3df 100644
--- a/arch/arm/src/sama5/sam_adc.c
+++ b/arch/arm/src/sama5/sam_adc.c
@@ -2152,15 +2152,15 @@ void sam_adc_lock(FAR struct sam_adc_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->exclsem);
+      ret = nxsem_wait(&priv->exclsem);
 
       /* This should only fail if the wait was canceled by an signal
        * (and the worker thread will receive a lot of signals).
        */
 
-      DEBUGASSERT(ret == OK || errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/sama5/sam_can.c b/arch/arm/src/sama5/sam_can.c
index faecc71d86..956ae680e8 100644
--- a/arch/arm/src/sama5/sam_can.c
+++ b/arch/arm/src/sama5/sam_can.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/sama5/sam_can.c
  *
- *   Copyright (C) 2013-2014 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013-2014, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References:
@@ -567,10 +567,10 @@ static void can_semtake(FAR struct sam_can_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->exclsem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(&priv->exclsem);
+      DEBUGASSERT(ret == 0 || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/sama5/sam_dmac.c b/arch/arm/src/sama5/sam_dmac.c
index 6811dbaf26..c1c70ccd7f 100644
--- a/arch/arm/src/sama5/sam_dmac.c
+++ b/arch/arm/src/sama5/sam_dmac.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/sama5/sam3u_dmac.c
  *
- *   Copyright (C) 2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -487,16 +487,21 @@ static struct sam_dmac_s g_dmac1 =
 
 static void sam_takechsem(struct sam_dmac_s *dmac)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&dmac->chsem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&dmac->chsem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void sam_givechsem(struct sam_dmac_s *dmac)
@@ -514,16 +519,21 @@ static inline void sam_givechsem(struct sam_dmac_s *dmac)
 
 static void sam_takedsem(struct sam_dmac_s *dmac)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&dmac->dsem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&dmac->dsem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void sam_givedsem(struct sam_dmac_s *dmac)
diff --git a/arch/arm/src/sama5/sam_ehci.c b/arch/arm/src/sama5/sam_ehci.c
index adf295b6a0..d6538ced75 100644
--- a/arch/arm/src/sama5/sam_ehci.c
+++ b/arch/arm/src/sama5/sam_ehci.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/sama5/sam_ehci.c
  *
- *   Copyright (C) 2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013, 2016-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -815,16 +815,21 @@ static int ehci_wait_usbsts(uint32_t maskbits, uint32_t donebits,
 
 static void sam_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/sama5/sam_hsmci.c b/arch/arm/src/sama5/sam_hsmci.c
index afaf1e784e..1e6b476106 100644
--- a/arch/arm/src/sama5/sam_hsmci.c
+++ b/arch/arm/src/sama5/sam_hsmci.c
@@ -678,16 +678,21 @@ static struct sam_dev_s g_hsmci2;
 
 static void sam_takesem(struct sam_dev_s *priv)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&priv->waitsem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->waitsem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/sama5/sam_nand.c b/arch/arm/src/sama5/sam_nand.c
index 0dec9827e6..ae0c22936d 100644
--- a/arch/arm/src/sama5/sam_nand.c
+++ b/arch/arm/src/sama5/sam_nand.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/sama5/sam_nand.c
  *
- *   Copyright (C) 2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References:
@@ -318,10 +318,10 @@ void nand_lock(void)
 
   do
     {
-      ret = sem_wait(&g_nand.exclsem);
-      DEBUGASSERT(ret == OK || errno == EINTR);
+      ret = nxsem_wait(&g_nand.exclsem);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
-  while (ret != OK);
+  while (ret == -EINTR);
 }
 #endif
 
@@ -689,11 +689,8 @@ static void nand_wait_cmddone(struct sam_nandcs_s *priv)
   flags = enter_critical_section();
   do
     {
-      ret = sem_wait(&g_nand.waitsem);
-      if (ret < 0)
-        {
-          DEBUGASSERT(errno == EINTR);
-        }
+      ret = nxsem_wait(&g_nand.waitsem);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
   while (!g_nand.cmddone);
 
@@ -780,11 +777,8 @@ static void nand_wait_xfrdone(struct sam_nandcs_s *priv)
   flags = enter_critical_section();
   do
     {
-      ret = sem_wait(&g_nand.waitsem);
-      if (ret < 0)
-        {
-          DEBUGASSERT(errno == EINTR);
-        }
+      ret = nxsem_wait(&g_nand.waitsem);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
   while (!g_nand.xfrdone);
 
@@ -871,11 +865,8 @@ static void nand_wait_rbedge(struct sam_nandcs_s *priv)
   flags = enter_critical_section();
   do
     {
-      ret = sem_wait(&g_nand.waitsem);
-      if (ret < 0)
-        {
-          DEBUGASSERT(errno == EINTR);
-        }
+      ret = nxsem_wait(&g_nand.waitsem);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
   while (!g_nand.rbedge);
 
@@ -1227,11 +1218,8 @@ static int nand_wait_dma(struct sam_nandcs_s *priv)
 
   while (!priv->dmadone)
     {
-      ret = sem_wait(&priv->waitsem);
-      if (ret < 0)
-        {
-          DEBUGASSERT(errno == EINTR);
-        }
+      ret = nxsem_wait(&priv->waitsem);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
 
   finfo("Awakened: result=%d\n", priv->result);
diff --git a/arch/arm/src/sama5/sam_ohci.c b/arch/arm/src/sama5/sam_ohci.c
index f2928af260..7b87c382c6 100644
--- a/arch/arm/src/sama5/sam_ohci.c
+++ b/arch/arm/src/sama5/sam_ohci.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/sama5/sam_ohci.c
  *
- *   Copyright (C) 2013, 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013, 2015-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -643,16 +643,21 @@ static void sam_putreg(uint32_t val, uint32_t addr)
 
 static void sam_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/sama5/sam_pmecc.c b/arch/arm/src/sama5/sam_pmecc.c
index c33c897ee5..75ff66279c 100644
--- a/arch/arm/src/sama5/sam_pmecc.c
+++ b/arch/arm/src/sama5/sam_pmecc.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/sama5/sam_pmecc.c
  *
- *   Copyright (C) 2013 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References:
@@ -1240,10 +1240,10 @@ void pmecc_lock(void)
 
   do
     {
-      ret = sem_wait(&g_pmecc.exclsem);
-      DEBUGASSERT(ret == OK || errno == EINTR);
+      ret = nxsem_wait(&g_pmecc.exclsem);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
-  while (ret != OK);
+  while (ret == -EINTR);
 }
 #endif
 
diff --git a/arch/arm/src/sama5/sam_spi.c b/arch/arm/src/sama5/sam_spi.c
index 8a832da688..ce398400f4 100644
--- a/arch/arm/src/sama5/sam_spi.c
+++ b/arch/arm/src/sama5/sam_spi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/sama5/sam_spi.c
  *
- *   Copyright (C) 2013-2014, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013-2014, 2016-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *
  * This derives from SAM3/4 SPI driver:
@@ -865,27 +865,34 @@ static int spi_lock(struct spi_dev_s *dev, bool lock)
 {
   struct sam_spics_s *spics = (struct sam_spics_s *)dev;
   struct sam_spidev_s *spi = spi_device(spics);
+  int ret;
 
   spiinfo("lock=%d\n", lock);
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&spi->spisem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          /* Take the semaphore (perhaps waiting) */
+
+          ret = nxsem_wait(&spi->spisem);
+
+          /* The only case that an error should occur here is if the wait was
+           * awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&spi->spisem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
@@ -1520,26 +1527,20 @@ static void spi_exchange(struct spi_dev_s *dev, const void *txbuffer,
 
       /* Wait for the DMA complete */
 
-      ret = sem_wait(&spics->dmawait);
+      ret = nxsem_wait(&spics->dmawait);
 
       /* Cancel the watchdog timeout */
 
       (void)wd_cancel(spics->dmadog);
 
-      /* Check if we were awakened by an error of some kind */
+      /* Check if we were awakened by an error of some kind.  EINTR is not a
+       * failure.  It simply means that the wait was awakened by a signal.
+       */
 
-      if (ret < 0)
+      if (ret < 0 && ret != -EINTR)
         {
-          /* EINTR is not a failure.  That simply means that the wait
-           * was awakened by a signel.
-           */
-
-          int errorcode = errno;
-          if (errorcode != EINTR)
-            {
-              DEBUGPANIC();
-              return;
-            }
+          DEBUGPANIC();
+          return;
         }
 
       /* Not that we might be awkened before the wait is over due to
diff --git a/arch/arm/src/sama5/sam_ssc.c b/arch/arm/src/sama5/sam_ssc.c
index 0b547fcd10..0c86991030 100644
--- a/arch/arm/src/sama5/sam_ssc.c
+++ b/arch/arm/src/sama5/sam_ssc.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/sama5/sam_ssc.c
  *
- *   Copyright (C) 2013-2014, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013-2014, 2016-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -898,10 +898,10 @@ static void ssc_exclsem_take(struct sam_ssc_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->exclsem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(&priv->exclsem);
+      DEBUGASSERT(ret == 0 || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
@@ -929,10 +929,10 @@ static void ssc_bufsem_take(struct sam_ssc_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->bufsem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(&priv->bufsem);
+      DEBUGASSERT(ret == 0 || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/sama5/sam_tc.c b/arch/arm/src/sama5/sam_tc.c
index 86c42a04a3..a0a3f79198 100644
--- a/arch/arm/src/sama5/sam_tc.c
+++ b/arch/arm/src/sama5/sam_tc.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/sama5/sam_tc.c
  *
- *   Copyright (C) 2013-2014, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013-2014, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References:
@@ -471,16 +471,21 @@ static const uint8_t g_regoffset[TC_NREGISTERS] =
 
 static void sam_takesem(struct sam_tc_s *tc)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&tc->exclsem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&tc->exclsem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/sama5/sam_trng.c b/arch/arm/src/sama5/sam_trng.c
index b269dc7c4c..c224492539 100644
--- a/arch/arm/src/sama5/sam_trng.c
+++ b/arch/arm/src/sama5/sam_trng.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/sama5/sam_trng.c
  *
- *   Copyright (C) 2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Derives, in part, from Max Holtzberg's STM32 RNG Nuttx driver:
@@ -253,11 +253,12 @@ static ssize_t sam_read(struct file *filep, char *buffer, size_t buflen)
 
   /* Get exclusive access to the TRNG harware */
 
-  if (sem_wait(&g_trngdev.exclsem) != OK)
+  ret = nxsem_wait(&g_trngdev.exclsem);
+  if (ret < 0)
     {
       /* This is probably -EINTR meaning that we were awakened by a signal */
 
-      return -errno;
+      return ret;
     }
 
   /* Save the buffer information. */
@@ -287,7 +288,7 @@ static ssize_t sam_read(struct file *filep, char *buffer, size_t buflen)
 
   while (g_trngdev.nsamples < g_trngdev.maxsamples)
     {
-      ret = sem_wait(&g_trngdev.waitsem);
+      ret = nxsem_wait(&g_trngdev.waitsem);
 
       finfo("Awakened: nsamples=%d maxsamples=%d ret=%d\n",
             g_trngdev.nsamples, g_trngdev.maxsamples, ret);
@@ -302,7 +303,7 @@ static ssize_t sam_read(struct file *filep, char *buffer, size_t buflen)
             }
           else
             {
-              retval = -errno;
+              retval = ret;
               goto errout;
             }
         }
diff --git a/arch/arm/src/sama5/sam_tsd.c b/arch/arm/src/sama5/sam_tsd.c
index 78e1c48914..4ec8d1bf04 100644
--- a/arch/arm/src/sama5/sam_tsd.c
+++ b/arch/arm/src/sama5/sam_tsd.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/sama5/sam_tsd.c
  *
- *   Copyright (C) 2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013, 2016-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *
  * References:
@@ -383,7 +383,7 @@ static int sam_tsd_waitsample(struct sam_tsd_s *priv, struct sam_sample_s *sampl
 
       iinfo("Waiting..\n");
       priv->nwaiters++;
-      ret = sem_wait(&priv->waitsem);
+      ret = nxsem_wait(&priv->waitsem);
       priv->nwaiters--;
 
       if (ret < 0)
@@ -392,9 +392,8 @@ static int sam_tsd_waitsample(struct sam_tsd_s *priv, struct sam_sample_s *sampl
            * the failure now.
            */
 
-          ierr("ERROR: sem_wait: %d\n", errno);
-          DEBUGASSERT(errno == EINTR);
-          ret = -EINTR;
+          ierr("ERROR: nxsem_wait: %d\n", ret);
+          DEBUGASSERT(ret == -EINTR);
           goto errout;
         }
     }
diff --git a/arch/arm/src/sama5/sam_twi.c b/arch/arm/src/sama5/sam_twi.c
index 86fdc4dfd7..7e32dd7720 100644
--- a/arch/arm/src/sama5/sam_twi.c
+++ b/arch/arm/src/sama5/sam_twi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/sama5/sam_twi.c
  *
- *   Copyright (C) 2013-2014, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013-2014, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References:
@@ -309,16 +309,21 @@ static const struct i2c_ops_s g_twiops =
 
 static void twi_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/sama5/sam_xdmac.c b/arch/arm/src/sama5/sam_xdmac.c
index 0be2e34fd2..11b38fbd03 100644
--- a/arch/arm/src/sama5/sam_xdmac.c
+++ b/arch/arm/src/sama5/sam_xdmac.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/sama5/sam_xdmac.c
  *
- *   Copyright (C) 2014, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -645,16 +645,21 @@ static struct sam_xdmac_s g_xdmac1 =
 
 static void sam_takechsem(struct sam_xdmac_s *xdmac)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&xdmac->chsem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&xdmac->chsem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void sam_givechsem(struct sam_xdmac_s *xdmac)
@@ -672,16 +677,21 @@ static inline void sam_givechsem(struct sam_xdmac_s *xdmac)
 
 static void sam_takedsem(struct sam_xdmac_s *xdmac)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&xdmac->dsem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&xdmac->dsem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void sam_givedsem(struct sam_xdmac_s *xdmac)
diff --git a/arch/arm/src/samdl/sam_dmac.c b/arch/arm/src/samdl/sam_dmac.c
index 67811042a4..5ca812ea4f 100644
--- a/arch/arm/src/samdl/sam_dmac.c
+++ b/arch/arm/src/samdl/sam_dmac.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/samdl/sam_dmac.c
  *
- *   Copyright (C) 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -178,16 +178,21 @@ static struct dma_desc_s g_dma_desc[CONFIG_SAMDL_DMAC_NDESC]
 
 static void sam_takechsem(void)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&g_chsem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&g_chsem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void sam_givechsem(void)
@@ -206,16 +211,21 @@ static inline void sam_givechsem(void)
 #if CONFIG_SAMDL_DMAC_NDESC > 0
 static void sam_takedsem(void)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&g_dsem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&g_dsem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void sam_givedsem(void)
diff --git a/arch/arm/src/samdl/sam_i2c_master.c b/arch/arm/src/samdl/sam_i2c_master.c
index 987e46cbb4..34999af681 100644
--- a/arch/arm/src/samdl/sam_i2c_master.c
+++ b/arch/arm/src/samdl/sam_i2c_master.c
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * arch/arm/src/samdl/sam_i2c_master.c
  *
- *   Copyright (C) 2013-2014 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013-2014, 2017 Gregory Nutt. All rights reserved.
  *   Copyright (C) 2015 Filament - www.filament.com
  *   Author: Matt Thompson <mthompson@hexwave.com>
  *   Author: Alan Carvalho de Assis <acassis@gmail.com>
@@ -460,18 +460,23 @@ static void i2c_putreg32(struct sam_i2c_dev_s *priv, uint32_t regval,
  *
  *******************************************************************************/
 
-static void i2c_takesem(sem_t * sem)
+static void i2c_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /*******************************************************************************
diff --git a/arch/arm/src/samdl/sam_spi.c b/arch/arm/src/samdl/sam_spi.c
index e4f7d024dd..1f945b7659 100644
--- a/arch/arm/src/samdl/sam_spi.c
+++ b/arch/arm/src/samdl/sam_spi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/samdl/sam_spi.c
  *
- *   Copyright (C) 2014-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *
  * References:
@@ -780,27 +780,32 @@ static int spi_interrupt(int irq, void *context, FAR void *arg)
 static int spi_lock(struct spi_dev_s *dev, bool lock)
 {
   struct sam_spidev_s *priv = (struct sam_spidev_s *)dev;
+  int ret;
 
   spiinfo("lock=%d\n", lock);
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->spilock) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->spilock);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->spilock);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/samv7/sam_hsmci.c b/arch/arm/src/samv7/sam_hsmci.c
index ab5aab3d07..687154ae0b 100644
--- a/arch/arm/src/samv7/sam_hsmci.c
+++ b/arch/arm/src/samv7/sam_hsmci.c
@@ -610,16 +610,21 @@ static struct sam_dev_s g_hsmci1;
 
 static void sam_takesem(struct sam_dev_s *priv)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&priv->waitsem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->waitsem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/samv7/sam_mcan.c b/arch/arm/src/samv7/sam_mcan.c
index c00334ac81..e72d089dc7 100644
--- a/arch/arm/src/samv7/sam_mcan.c
+++ b/arch/arm/src/samv7/sam_mcan.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/samv7/sam_mcan.c
  *
- *   Copyright (C) 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References:
@@ -1381,10 +1381,10 @@ static void mcan_dev_lock(FAR struct sam_mcan_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->locksem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(&priv->locksem);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
@@ -1548,9 +1548,9 @@ static void mcan_buffer_reserve(FAR struct sam_mcan_s *priv)
 
       /* The semaphore value is reasonable.  Wait for the next TC interrupt. */
 
-      ret = sem_wait(&priv->txfsem);
+      ret = nxsem_wait(&priv->txfsem);
       leave_critical_section(flags);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
   while (ret < 0);
 }
diff --git a/arch/arm/src/samv7/sam_progmem.c b/arch/arm/src/samv7/sam_progmem.c
index 092134989d..f2ba6d14f6 100644
--- a/arch/arm/src/samv7/sam_progmem.c
+++ b/arch/arm/src/samv7/sam_progmem.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/samv7/sam_progmem.c
  *
- *   Copyright (C) 2015 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -186,18 +186,21 @@ static sem_t g_page_sem;
 
 static void page_buffer_lock(void)
 {
-  while (sem_wait(&g_page_sem) < 0)
+  int ret;
+
+  do
     {
-      int errcode = errno;
+      /* Take the semaphore (perhaps waiting) */
 
-      /* sem_wait should only fail if it was awakened by a signal */
+      ret = nxsem_wait(&g_page_sem);
 
-      DEBUGASSERT(errcode == EINTR);
-      if (errcode != EINTR)
-        {
-          break;
-        }
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 #define page_buffer_unlock() nxsem_post(&g_page_sem)
diff --git a/arch/arm/src/samv7/sam_qspi.c b/arch/arm/src/samv7/sam_qspi.c
index d8aeb6d955..e2ff6dea79 100644
--- a/arch/arm/src/samv7/sam_qspi.c
+++ b/arch/arm/src/samv7/sam_qspi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/samv7/sam_qspi.c
  *
- *   Copyright (C) 2015 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015, 2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -892,26 +892,20 @@ static int qspi_memory_dma(struct sam_qspidev_s *priv,
 
       /* Wait for the DMA complete */
 
-      ret = sem_wait(&priv->dmawait);
+      ret = nxsem_wait(&priv->dmawait);
 
       /* Cancel the watchdog timeout */
 
       (void)wd_cancel(priv->dmadog);
 
-      /* Check if we were awakened by an error of some kind */
+      /* Check if we were awakened by an error of some kind.  EINTR is not a
+       * failure.  That simply means that the wait was awakened by a signal.
+       */
 
-      if (ret < 0)
+      if (ret < 0 && ret != -EINTR)
         {
-          /* EINTR is not a failure.  That simply means that the wait
-           * was awakened by a signal.
-           */
-
-          int errorcode = errno;
-          if (errorcode != EINTR)
-            {
-              DEBUGPANIC();
-              return -errorcode;
-            }
+          DEBUGPANIC();
+          return ret;
         }
 
       /* Not that we might be awakened before the wait is over due to
@@ -1061,27 +1055,32 @@ static void qspi_memcpy(uint8_t *dest, const uint8_t *src, size_t buflen)
 static int qspi_lock(struct qspi_dev_s *dev, bool lock)
 {
   struct sam_qspidev_s *priv = (struct sam_qspidev_s *)dev;
+  int ret;
 
   spiinfo("lock=%d\n", lock);
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/samv7/sam_spi.c b/arch/arm/src/samv7/sam_spi.c
index a8c82906e8..e45fac7d00 100644
--- a/arch/arm/src/samv7/sam_spi.c
+++ b/arch/arm/src/samv7/sam_spi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/samv7/sam_spi.c
  *
- *   Copyright (C) 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *            Diego Sanchez <dsanchez@nx-engineering.com>
  *
@@ -903,27 +903,34 @@ static int spi_lock(struct spi_dev_s *dev, bool lock)
 {
   struct sam_spics_s *spics = (struct sam_spics_s *)dev;
   struct sam_spidev_s *spi = spi_device(spics);
+  int ret;
 
   spiinfo("lock=%d\n", lock);
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&spi->spisem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          /* Take the semaphore (perhaps waiting) */
+
+          ret = nxsem_wait(&spi->spisem);
+
+          /* The only case that an error should occur here is if the wait was
+           * awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&spi->spisem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
@@ -1864,26 +1871,20 @@ static void spi_exchange(struct spi_dev_s *dev, const void *txbuffer,
 
       /* Wait for the DMA complete */
 
-      ret = sem_wait(&spics->dmawait);
+      ret = nxsem_wait(&spics->dmawait);
 
       /* Cancel the watchdog timeout */
 
       (void)wd_cancel(spics->dmadog);
 
-      /* Check if we were awakened by an error of some kind */
+      /* Check if we were awakened by an error of some kind.  EINTR is not a
+       * failure.  It simply means that the wait was awakened by a signal.
+       */
 
-      if (ret < 0)
+      if (ret < 0 && ret != -EINTR)
         {
-          /* EINTR is not a failure.  That simply means that the wait
-           * was awakened by a signal.
-           */
-
-          int errorcode = errno;
-          if (errorcode != EINTR)
-            {
-              DEBUGPANIC();
-              return;
-            }
+          DEBUGPANIC();
+          return;
         }
 
       /* Not that we might be awakened before the wait is over due to
diff --git a/arch/arm/src/samv7/sam_spi_slave.c b/arch/arm/src/samv7/sam_spi_slave.c
index 43a12e3094..19473aa05c 100644
--- a/arch/arm/src/samv7/sam_spi_slave.c
+++ b/arch/arm/src/samv7/sam_spi_slave.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/samv7/sam_spi_slave.c
  *
- *   Copyright (C) 2015 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015, 2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -369,10 +369,10 @@ static void spi_semtake(struct sam_spidev_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->spisem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(&priv->spisem);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/samv7/sam_ssc.c b/arch/arm/src/samv7/sam_ssc.c
index 1b028afdf8..bb1114c444 100644
--- a/arch/arm/src/samv7/sam_ssc.c
+++ b/arch/arm/src/samv7/sam_ssc.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/samv7/sam_ssc.c
  *
- *   Copyright (C) 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -872,10 +872,10 @@ static void ssc_exclsem_take(struct sam_ssc_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->exclsem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(&priv->exclsem);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
@@ -903,10 +903,10 @@ static void ssc_bufsem_take(struct sam_ssc_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->bufsem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(&priv->bufsem);
+      DEBUGASSERT(ret == 0 || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/samv7/sam_tc.c b/arch/arm/src/samv7/sam_tc.c
index f542f390c5..e2b1961777 100644
--- a/arch/arm/src/samv7/sam_tc.c
+++ b/arch/arm/src/samv7/sam_tc.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/SAMV7/sam_tc.c
  *
- *   Copyright (C) 2015=2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References:
@@ -610,16 +610,21 @@ static const uint8_t g_regoffset[TC_NREGISTERS] =
 
 static void sam_takesem(struct sam_tc_s *tc)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&tc->exclsem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&tc->exclsem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/samv7/sam_trng.c b/arch/arm/src/samv7/sam_trng.c
index 7bb76dc547..824724ea1d 100644
--- a/arch/arm/src/samv7/sam_trng.c
+++ b/arch/arm/src/samv7/sam_trng.c
@@ -254,11 +254,12 @@ static ssize_t sam_read(struct file *filep, char *buffer, size_t buflen)
 
   /* Get exclusive access to the TRNG harware */
 
-  if (sem_wait(&g_trngdev.exclsem) != OK)
+  ret = nxsem_wait(&g_trngdev.exclsem);
+  if (ret < 0)
     {
       /* This is probably -EINTR meaning that we were awakened by a signal */
 
-      return -errno;
+      return ret;
     }
 
   /* Save the buffer information. */
@@ -288,7 +289,7 @@ static ssize_t sam_read(struct file *filep, char *buffer, size_t buflen)
 
   while (g_trngdev.nsamples < g_trngdev.maxsamples)
     {
-      ret = sem_wait(&g_trngdev.waitsem);
+      ret = nxsem_wait(&g_trngdev.waitsem);
 
       finfo("Awakened: nsamples=%d maxsamples=%d ret=%d\n",
             g_trngdev.nsamples, g_trngdev.maxsamples, ret);
@@ -303,7 +304,7 @@ static ssize_t sam_read(struct file *filep, char *buffer, size_t buflen)
             }
           else
             {
-              retval = -errno;
+              retval = ret;
               goto errout;
             }
         }
diff --git a/arch/arm/src/samv7/sam_twihs.c b/arch/arm/src/samv7/sam_twihs.c
index 07704dd938..ca54bd3854 100644
--- a/arch/arm/src/samv7/sam_twihs.c
+++ b/arch/arm/src/samv7/sam_twihs.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/samv7/sam_twihs.c
  *
- *   Copyright (C) 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * This driver derives from the SAMA5Dx TWIHS driver.  References:
@@ -313,16 +313,21 @@ static const struct i2c_ops_s g_twiops =
 
 static void twi_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      DEBUGASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/samv7/sam_xdmac.c b/arch/arm/src/samv7/sam_xdmac.c
index b00f77816c..2a5d190f37 100644
--- a/arch/arm/src/samv7/sam_xdmac.c
+++ b/arch/arm/src/samv7/sam_xdmac.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/samv7/sam_xdmac.c
  *
- *   Copyright (C) 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -370,16 +370,21 @@ static struct sam_xdmac_s g_xdmac;
 
 static void sam_takechsem(struct sam_xdmac_s *xdmac)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&xdmac->chsem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&xdmac->chsem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void sam_givechsem(struct sam_xdmac_s *xdmac)
@@ -397,16 +402,21 @@ static inline void sam_givechsem(struct sam_xdmac_s *xdmac)
 
 static void sam_takedsem(struct sam_xdmac_s *xdmac)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&xdmac->dsem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&xdmac->dsem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void sam_givedsem(struct sam_xdmac_s *xdmac)
diff --git a/arch/arm/src/stm32/stm32_1wire.c b/arch/arm/src/stm32/stm32_1wire.c
index 1cc81a33a2..a917348f9e 100644
--- a/arch/arm/src/stm32/stm32_1wire.c
+++ b/arch/arm/src/stm32/stm32_1wire.c
@@ -742,10 +742,21 @@ static inline void stm32_1wire_sem_destroy(FAR struct stm32_1wire_priv_s *priv)
 
 static inline void stm32_1wire_sem_wait(FAR struct stm32_1wire_priv_s *priv)
 {
-  while (sem_wait(&priv->sem_excl) != 0)
+  int ret;
+
+  do
     {
-      ASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->sem_excl);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/stm32/stm32_aes.c b/arch/arm/src/stm32/stm32_aes.c
index 801050c546..5dcb9dc536 100644
--- a/arch/arm/src/stm32/stm32_aes.c
+++ b/arch/arm/src/stm32/stm32_aes.c
@@ -234,7 +234,7 @@ int aes_cypher(void *out, const void *in, uint32_t size, const void *iv,
       return -EINVAL;
     }
 
-  ret = sem_wait(&aes_lock);
+  ret = nxsem_wait(&aes_lock);
   if (ret < 0)
     {
       return ret;
diff --git a/arch/arm/src/stm32/stm32_bbsram.c b/arch/arm/src/stm32/stm32_bbsram.c
index 1b3d19168f..ccb7add380 100644
--- a/arch/arm/src/stm32/stm32_bbsram.c
+++ b/arch/arm/src/stm32/stm32_bbsram.c
@@ -233,10 +233,10 @@ static void stm32_bbsram_semtake(FAR struct stm32_bbsram_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->exclsem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(&priv->exclsem);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/stm32/stm32_dma2d.c b/arch/arm/src/stm32/stm32_dma2d.c
index b628867221..e2a3a2278c 100644
--- a/arch/arm/src/stm32/stm32_dma2d.c
+++ b/arch/arm/src/stm32/stm32_dma2d.c
@@ -506,15 +506,15 @@ static int stm32_dma2d_waitforirq(void)
 
       priv->wait = true;
 
-      ret = sem_wait(priv->sem);
+      ret = nxsem_wait(priv->sem);
 
       /* irq or an error occurs, reset the wait flag */
 
       priv->wait = false;
 
-      if (ret != OK)
+      if (ret < 0)
         {
-          lcderr("ERROR: sem_wait() failed\n");
+          lcderr("ERROR: nxsem_wait() failed\n");
           return ret;
         }
     }
@@ -1178,7 +1178,7 @@ static int stm32_dma2dgetvideoinfo(FAR struct dma2d_layer_s *layer,
 
   if (stm32_dma2d_lvalidate(priv) && vinfo)
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
       memcpy(vinfo, &priv->vinfo, sizeof(struct fb_videoinfo_s));
       nxsem_post(priv->lock);
 
@@ -1215,7 +1215,7 @@ static int stm32_dma2dgetplaneinfo(FAR struct dma2d_layer_s *layer, int planeno,
 
   if (stm32_dma2d_lvalidate(priv) && pinfo && planeno == 0)
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
       memcpy(pinfo, &priv->pinfo, sizeof(struct fb_planeinfo_s));
       nxsem_post(priv->lock);
 
@@ -1250,7 +1250,7 @@ static int stm32_dma2dgetlid(FAR struct dma2d_layer_s *layer, int *lid)
 
   if (stm32_dma2d_lvalidate(priv) && lid)
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
       *lid = priv->lid;
       nxsem_post(priv->lock);
       return OK;
@@ -1288,7 +1288,7 @@ static int stm32_dma2dsetclut(FAR struct dma2d_layer_s *layer,
 
   if (stm32_dma2d_lvalidate(priv) && cmap)
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
 
 #ifdef CONFIG_STM32_LTDC_INTERFACE
       if (priv->lid < DMA2D_SHADOW_LAYER)
@@ -1407,7 +1407,7 @@ static int stm32_dma2dgetclut(FAR struct dma2d_layer_s *layer,
 
   if (stm32_dma2d_lvalidate(priv) && cmap)
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
 
       if (priv->fmt != DMA2D_PF_L8)
         {
@@ -1497,7 +1497,7 @@ static int stm32_dma2dsetalpha(FAR struct dma2d_layer_s *layer, uint8_t alpha)
 
   if (stm32_dma2d_lvalidate(priv))
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
       priv->alpha = alpha;
       nxsem_post(priv->lock);
 
@@ -1532,7 +1532,7 @@ static int stm32_dma2dgetalpha(FAR struct dma2d_layer_s *layer, uint8_t *alpha)
 
   if (stm32_dma2d_lvalidate(priv))
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
       *alpha = priv->alpha;
       nxsem_post(priv->lock);
 
@@ -1583,7 +1583,7 @@ static int stm32_dma2dsetblendmode(FAR struct dma2d_layer_s *layer,
 
   if (stm32_dma2d_lvalidate(priv))
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
       priv->blendmode = mode;
       nxsem_post(priv->lock);
 
@@ -1619,7 +1619,7 @@ static int stm32_dma2dgetblendmode(FAR struct dma2d_layer_s *layer,
 
   if (stm32_dma2d_lvalidate(priv) && mode)
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
       *mode = priv->blendmode;
       nxsem_post(priv->lock);
 
@@ -1670,7 +1670,7 @@ static int stm32_dma2dblit(FAR struct dma2d_layer_s *dest,
         stm32_dma2d_lvalidatesize(srclayer, srcarea->xpos,
                                     srcarea->ypos, srcarea))
     {
-      sem_wait(destlayer->lock);
+      nxsem_wait(destlayer->lock);
 
       /* Set output pfc */
 
@@ -1784,8 +1784,7 @@ static int stm32_dma2dblend(FAR struct dma2d_layer_s *dest,
             stm32_dma2d_lvalidatesize(backlayer, backarea->xpos,
                                         backarea->ypos, backarea))
     {
-
-      sem_wait(destlayer->lock);
+      nxsem_wait(destlayer->lock);
 
       /* Set output pfc */
 
@@ -1880,8 +1879,7 @@ static int stm32_dma2dfillarea(FAR struct dma2d_layer_s *layer,
 
   if (stm32_dma2d_lvalidatesize(priv, area->xpos, area->ypos, area))
     {
-
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
 
       /* Set output pfc */
 
@@ -1949,7 +1947,7 @@ FAR struct dma2d_layer_s *up_dma2dgetlayer(int lid)
   if (lid < DMA2D_LAYER_NSIZE)
     {
       FAR struct stm32_dma2d_s *priv;
-      sem_wait(&g_lock);
+      nxsem_wait(&g_lock);
       priv = g_layers[lid];
       nxsem_post(&g_lock);
 
@@ -2000,7 +1998,7 @@ FAR struct dma2d_layer_s *up_dma2dcreatelayer(fb_coord_t width,
 
   ret = stm32_dma2d_bpp(fmt, &bpp);
 
-  sem_wait(&g_lock);
+  nxsem_wait(&g_lock);
 
   /* Get a free layer identifier */
 
@@ -2108,7 +2106,7 @@ int up_dma2dremovelayer(FAR struct dma2d_layer_s *layer)
 
   if (stm32_dma2d_lvalidate(priv) && priv->lid >= DMA2D_SHADOW_LAYER)
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
 
       /* Check also if the layer id is valid to the layer reference */
 
diff --git a/arch/arm/src/stm32/stm32_flash.c b/arch/arm/src/stm32/stm32_flash.c
index 879e6ba146..0e4afb5995 100644
--- a/arch/arm/src/stm32/stm32_flash.c
+++ b/arch/arm/src/stm32/stm32_flash.c
@@ -108,10 +108,21 @@ static sem_t g_sem = SEM_INITIALIZER(1);
 
 static void sem_lock(void)
 {
-  while (sem_wait(&g_sem) < 0)
+  int ret;
+
+  do
     {
-      DEBUGASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&g_sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void sem_unlock(void)
diff --git a/arch/arm/src/stm32/stm32_i2c.c b/arch/arm/src/stm32/stm32_i2c.c
index 3c1d064f09..87c783f2ca 100644
--- a/arch/arm/src/stm32/stm32_i2c.c
+++ b/arch/arm/src/stm32/stm32_i2c.c
@@ -505,10 +505,21 @@ static inline void stm32_i2c_modifyreg(FAR struct stm32_i2c_priv_s *priv,
 
 static inline void stm32_i2c_sem_wait(FAR struct stm32_i2c_priv_s *priv)
 {
-  while (sem_wait(&priv->sem_excl) != 0)
+  int ret;
+
+  do
     {
-      ASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->sem_excl);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /************************************************************************************
diff --git a/arch/arm/src/stm32/stm32_i2c_alt.c b/arch/arm/src/stm32/stm32_i2c_alt.c
index fc34fd29ca..b772363a9d 100644
--- a/arch/arm/src/stm32/stm32_i2c_alt.c
+++ b/arch/arm/src/stm32/stm32_i2c_alt.c
@@ -513,10 +513,21 @@ static inline void stm32_i2c_modifyreg(FAR struct stm32_i2c_priv_s *priv,
 
 static inline void stm32_i2c_sem_wait(FAR struct stm32_i2c_priv_s *priv)
 {
-  while (sem_wait(&priv->sem_excl) != 0)
+  int ret;
+
+  do
     {
-      ASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->sem_excl);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /************************************************************************************
diff --git a/arch/arm/src/stm32/stm32_i2s.c b/arch/arm/src/stm32/stm32_i2s.c
index 0bcd98e114..46ac8f6eec 100644
--- a/arch/arm/src/stm32/stm32_i2s.c
+++ b/arch/arm/src/stm32/stm32_i2s.c
@@ -634,10 +634,10 @@ static void i2s_exclsem_take(struct stm32_i2s_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->exclsem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(&priv->exclsem);
+      DEBUGASSERT(ret == 0 || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
@@ -665,10 +665,10 @@ static void i2s_bufsem_take(struct stm32_i2s_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->bufsem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(&priv->bufsem);
+      DEBUGASSERT(ret == 0 || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/stm32/stm32_ltdc.c b/arch/arm/src/stm32/stm32_ltdc.c
index 7c9e7789f4..3a24ae8450 100644
--- a/arch/arm/src/stm32/stm32_ltdc.c
+++ b/arch/arm/src/stm32/stm32_ltdc.c
@@ -1194,15 +1194,15 @@ static int stm32_ltdc_waitforirq(void)
 
       priv->wait = true;
 
-      ret = sem_wait(priv->sem);
+      ret = nxsem_wait(priv->sem);
 
       /* irq or an error occurs, reset the wait flag */
 
       priv->wait = false;
 
-      if (ret != OK)
+      if (ret < 0)
         {
-          lcderr("ERROR: sem_wait() failed\n");
+          lcderr("ERROR: nxsem_wait() failed\n");
         }
     }
 
@@ -2395,7 +2395,7 @@ static int stm32_setclut(struct ltdc_layer_s *layer,
 
   if (stm32_ltdc_lvalidate(priv) && cmap)
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
 
       if (priv->state.vinfo.fmt != FB_FMT_RGB8)
         {
@@ -2454,7 +2454,7 @@ static int stm32_getclut(struct ltdc_layer_s *layer,
 
   if (priv == &LAYER_L1 || priv == &LAYER_L2)
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
 #ifdef CONFIG_STM32_DMA2D
       /* Note! We share the same color lookup table with the dma2d driver and
        * the getclut implementation works in the same way.
@@ -2554,7 +2554,7 @@ static int stm32_getlid(FAR struct ltdc_layer_s *layer, int *lid,
     {
       int   ret = OK;
 
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
 
       switch (flag)
         {
@@ -2628,7 +2628,7 @@ static int stm32_setcolor(FAR struct ltdc_layer_s *layer, uint32_t argb)
 
   if (stm32_ltdc_lvalidate(priv))
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       priv->state.color = argb;
       priv->operation |= LTDC_LAYER_SETCOLOR;
       nxsem_post(priv->state.lock);
@@ -2664,7 +2664,7 @@ static int stm32_getcolor(FAR struct ltdc_layer_s *layer, uint32_t *argb)
 
   if (stm32_ltdc_lvalidate(priv))
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       *argb = priv->state.color;
       nxsem_post(priv->state.lock);
 
@@ -2701,7 +2701,7 @@ static int stm32_setcolorkey(FAR struct ltdc_layer_s *layer, uint32_t rgb)
 
   if (stm32_ltdc_lvalidate(priv))
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       priv->state.colorkey = rgb;
       priv->operation |= LTDC_LAYER_SETCOLORKEY;
       nxsem_post(priv->state.lock);
@@ -2737,7 +2737,7 @@ static int stm32_getcolorkey(FAR struct ltdc_layer_s *layer, uint32_t *rgb)
 
   if (stm32_ltdc_lvalidate(priv))
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       *rgb = priv->state.colorkey;
       nxsem_post(priv->state.lock);
 
@@ -2778,7 +2778,7 @@ static int stm32_setalpha(FAR struct ltdc_layer_s *layer, uint8_t alpha)
 
   if (stm32_ltdc_lvalidate(priv))
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       priv->state.alpha = alpha;
       priv->operation  |= LTDC_LAYER_SETALPHAVALUE;
       nxsem_post(priv->state.lock);
@@ -2814,7 +2814,7 @@ static int stm32_getalpha(FAR struct ltdc_layer_s *layer, uint8_t *alpha)
 
   if (stm32_ltdc_lvalidate(priv))
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       *alpha = priv->state.alpha;
       nxsem_post(priv->state.lock);
 
@@ -2876,7 +2876,7 @@ static int stm32_setblendmode(FAR struct ltdc_layer_s *layer, uint32_t mode)
     {
       int         ret = OK;
 
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
 
       /* Disable colorkeying by default */
 
@@ -2982,7 +2982,7 @@ static int stm32_getblendmode(FAR struct ltdc_layer_s *layer, uint32_t *mode)
 
   if (stm32_ltdc_lvalidate(priv))
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       *mode = priv->state.blendmode;
       nxsem_post(priv->state.lock);
 
@@ -3033,7 +3033,7 @@ static int stm32_setarea(FAR struct ltdc_layer_s *layer,
     {
       int ret;
 
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
 
       ret = stm32_ltdc_lvalidatearea(priv, area->xpos, area->ypos, area->xres,
                                     area->yres, srcxpos, srcypos);
@@ -3087,7 +3087,7 @@ static int stm32_getarea(FAR struct ltdc_layer_s *layer,
 
   if (stm32_ltdc_lvalidate(priv))
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       *srcxpos = priv->state.xpos;
       *srcypos = priv->state.ypos;
       memcpy(area, &priv->state.area, sizeof(struct ltdc_area_s));
@@ -3156,7 +3156,7 @@ static int stm32_update(FAR struct ltdc_layer_s *layer, uint32_t mode)
       bool    waitvblank = false;
       uint8_t reload = LTDC_SRCR_IMR;
 
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
 
       if (mode & LTDC_SYNC_VBLANK)
         {
@@ -3295,7 +3295,7 @@ static int stm32_blit(FAR struct ltdc_layer_s *dest,
     {
       int   ret;
 
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       priv->dma2d->blit(priv->dma2d, destxpos, destypos, src, srcarea);
       nxsem_post(priv->state.lock);
 
@@ -3350,7 +3350,7 @@ static int stm32_blend(FAR struct ltdc_layer_s *dest,
     {
       int   ret;
 
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       priv->dma2d->blend(priv->dma2d, destxpos, destypos,
                         fore, forexpos, foreypos, back, backarea);
       nxsem_post(priv->state.lock);
@@ -3393,7 +3393,7 @@ static int stm32_fillarea(FAR struct ltdc_layer_s *layer,
     {
       int   ret;
 
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       priv->dma2d->fillarea(priv->dma2d, area, color);
       nxsem_post(priv->state.lock);
 
diff --git a/arch/arm/src/stm32/stm32_otgfshost.c b/arch/arm/src/stm32/stm32_otgfshost.c
index bb6928e1c6..7f1af4b40b 100644
--- a/arch/arm/src/stm32/stm32_otgfshost.c
+++ b/arch/arm/src/stm32/stm32_otgfshost.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/stm32/stm32_otgfshost.c
  *
- *   Copyright (C) 2012-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -643,16 +643,21 @@ static inline void stm32_modifyreg(uint32_t addr, uint32_t clrbits, uint32_t set
 
 static void stm32_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
@@ -1104,13 +1109,13 @@ static int stm32_chan_wait(FAR struct stm32_usbhost_s *priv,
        * wait here.
        */
 
-      ret = sem_wait(&chan->waitsem);
+      ret = nxsem_wait(&chan->waitsem);
 
-      /* sem_wait should succeed.  But it is possible that we could be
+      /* nxsem_wait should succeed.  But it is possible that we could be
        * awakened by a signal too.
        */
 
-      DEBUGASSERT(ret == OK || get_errno() == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
   while (chan->waiter);
 
diff --git a/arch/arm/src/stm32/stm32_otghshost.c b/arch/arm/src/stm32/stm32_otghshost.c
index 0d5b19e014..55bda25922 100644
--- a/arch/arm/src/stm32/stm32_otghshost.c
+++ b/arch/arm/src/stm32/stm32_otghshost.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/stm32/stm32_otghshost.c
  *
- *   Copyright (C) 2012-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -648,16 +648,21 @@ static inline void stm32_modifyreg(uint32_t addr, uint32_t clrbits, uint32_t set
 
 static void stm32_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
@@ -1109,9 +1114,9 @@ static int stm32_chan_wait(FAR struct stm32_usbhost_s *priv,
        * wait here.
        */
 
-      ret = sem_wait(&chan->waitsem);
+      ret = nxsem_wait(&chan->waitsem);
 
-      /* sem_wait should succeed.  But it is possible that we could be
+      /* nxsem_wait should succeed.  But it is possible that we could be
        * awakened by a signal too.
        */
 
diff --git a/arch/arm/src/stm32/stm32_rng.c b/arch/arm/src/stm32/stm32_rng.c
index 29f610f5a4..15925563e8 100644
--- a/arch/arm/src/stm32/stm32_rng.c
+++ b/arch/arm/src/stm32/stm32_rng.c
@@ -248,44 +248,38 @@ static ssize_t stm32_read(struct file *filep, char *buffer, size_t buflen)
 {
   int ret;
 
-  if (sem_wait(&g_rngdev.rd_devsem) < 0)
+  ret = nxsem_wait(&g_rngdev.rd_devsem);
+  if (ret < 0)
     {
-      return -get_errno();
+      return ret;
     }
-  else
-    {
-      /* We've got the semaphore. */
 
-      /* Initialize the operation semaphore with 0 for blocking until the
-       * buffer is filled from interrupts.  The readsem semaphore is used
-       * for signaling and, hence, should not have priority inheritance
-       * enabled.
-       */
+  /* We've got the semaphore. */
 
-      nxsem_init(&g_rngdev.rd_readsem, 0, 0);
-      nxsem_setprotocol(&g_rngdev.rd_readsem, SEM_PRIO_NONE);
+  /* Initialize the operation semaphore with 0 for blocking until the
+   * buffer is filled from interrupts.  The readsem semaphore is used
+   * for signaling and, hence, should not have priority inheritance
+   * enabled.
+   */
 
-      g_rngdev.rd_buflen = buflen;
-      g_rngdev.rd_buf = buffer;
+  nxsem_init(&g_rngdev.rd_readsem, 0, 0);
+  nxsem_setprotocol(&g_rngdev.rd_readsem, SEM_PRIO_NONE);
 
-      /* Enable RNG with interrupts */
+  g_rngdev.rd_buflen = buflen;
+  g_rngdev.rd_buf = buffer;
 
-      stm32_enable();
+  /* Enable RNG with interrupts */
 
-      /* Wait until the buffer is filled */
+  stm32_enable();
 
-      ret = sem_wait(&g_rngdev.rd_readsem);
-      if (ret < 0)
-        {
-          ret = -get_errno();
-        }
+  /* Wait until the buffer is filled */
 
-      /* Free RNG for next use */
+  ret = nxsem_wait(&g_rngdev.rd_readsem);
 
-      nxsem_post(&g_rngdev.rd_devsem);
+  /* Free RNG for next use */
 
-      return ret < 0 ? ret : buflen;
-    }
+  nxsem_post(&g_rngdev.rd_devsem);
+  return ret < 0 ? ret : buflen;
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/stm32/stm32_sdio.c b/arch/arm/src/stm32/stm32_sdio.c
index 96d897fc7d..31ecd08604 100644
--- a/arch/arm/src/stm32/stm32_sdio.c
+++ b/arch/arm/src/stm32/stm32_sdio.c
@@ -582,16 +582,21 @@ static struct stm32_sampleregs_s g_sampleregs[DEBUG_NSAMPLES];
 
 static void stm32_takesem(struct stm32_dev_s *priv)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&priv->waitsem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->waitsem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/stm32/stm32_spi.c b/arch/arm/src/stm32/stm32_spi.c
index f3c7628458..71f6dbfb3a 100644
--- a/arch/arm/src/stm32/stm32_spi.c
+++ b/arch/arm/src/stm32/stm32_spi.c
@@ -1,7 +1,7 @@
 /************************************************************************************
  * arch/arm/src/stm32/stm32_spi.c
  *
- *   Copyright (C) 2009-2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2009-2013, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -742,18 +742,23 @@ static inline bool spi_16bitmode(FAR struct stm32_spidev_s *priv)
 #ifdef CONFIG_STM32_SPI_DMA
 static void spi_dmarxwait(FAR struct stm32_spidev_s *priv)
 {
+  int ret;
+
   /* Take the semaphore (perhaps waiting).  If the result is zero, then the DMA
    * must not really have completed???
    */
 
-  while (sem_wait(&priv->rxsem) != 0 || priv->rxresult == 0)
+  do
     {
-      /* The only case that an error should occur here is if the wait was awakened
-       * by a signal.
+      ret = nxsem_wait(&priv->rxsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR || priv->rxresult == 0);
 }
 #endif
 
@@ -768,18 +773,23 @@ static void spi_dmarxwait(FAR struct stm32_spidev_s *priv)
 #ifdef CONFIG_STM32_SPI_DMA
 static void spi_dmatxwait(FAR struct stm32_spidev_s *priv)
 {
+  int ret;
+
   /* Take the semaphore (perhaps waiting).  If the result is zero, then the DMA
    * must not really have completed???
    */
 
-  while (sem_wait(&priv->txsem) != 0 || priv->txresult == 0)
+  do
     {
-      /* The only case that an error should occur here is if the wait was awakened
-       * by a signal.
+      ret = nxsem_wait(&priv->txsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR || priv->txresult == 0);
 }
 #endif
 
@@ -1064,25 +1074,31 @@ static void spi_modifycr2(FAR struct stm32_spidev_s *priv, uint16_t setbits,
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct stm32_spidev_s *priv = (FAR struct stm32_spidev_s *)dev;
+  int ret;
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
-  return OK;
+
+  return ret;
 }
 
 /************************************************************************************
diff --git a/arch/arm/src/stm32/stm32f10xxx_dma.c b/arch/arm/src/stm32/stm32f10xxx_dma.c
index 5926959af6..c3c666e937 100644
--- a/arch/arm/src/stm32/stm32f10xxx_dma.c
+++ b/arch/arm/src/stm32/stm32f10xxx_dma.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/stm32/stm32f10xxx_dma.c
  *
- *   Copyright (C) 2009, 2011-2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2009, 2011-2013, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -224,16 +224,21 @@ static inline void dmachan_putreg(struct stm32_dma_s *dmach, uint32_t offset, ui
 
 static void stm32_dmatake(FAR struct stm32_dma_s *dmach)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&dmach->sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if the wait was awakened
-       * by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&dmach->sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void stm32_dmagive(FAR struct stm32_dma_s *dmach)
diff --git a/arch/arm/src/stm32/stm32f20xxx_dma.c b/arch/arm/src/stm32/stm32f20xxx_dma.c
index 304b6e198b..f355c9b0ac 100644
--- a/arch/arm/src/stm32/stm32f20xxx_dma.c
+++ b/arch/arm/src/stm32/stm32f20xxx_dma.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/stm32/stm32f20xxx_dma.c
  *
- *   Copyright (C) 2012-2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012-2013, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -253,16 +253,21 @@ static inline void dmast_putreg(struct stm32_dma_s *dmast, uint32_t offset, uint
 
 static void stm32_dmatake(FAR struct stm32_dma_s *dmast)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&dmast->sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if the wait was awakened
-       * by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&dmast->sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void stm32_dmagive(FAR struct stm32_dma_s *dmast)
diff --git a/arch/arm/src/stm32/stm32f30xxx_i2c.c b/arch/arm/src/stm32/stm32f30xxx_i2c.c
index c0746ac77c..7a1fad370a 100644
--- a/arch/arm/src/stm32/stm32f30xxx_i2c.c
+++ b/arch/arm/src/stm32/stm32f30xxx_i2c.c
@@ -513,10 +513,21 @@ static inline void stm32_i2c_modifyreg32(FAR struct stm32_i2c_priv_s *priv,
 
 static inline void stm32_i2c_sem_wait(FAR struct stm32_i2c_priv_s *priv)
 {
-  while (sem_wait(&priv->sem_excl) != 0)
+  int ret;
+
+  do
     {
-      ASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->sem_excl);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /************************************************************************************
diff --git a/arch/arm/src/stm32/stm32f33xxx_dma.c b/arch/arm/src/stm32/stm32f33xxx_dma.c
index e39e5814be..e23a64414f 100644
--- a/arch/arm/src/stm32/stm32f33xxx_dma.c
+++ b/arch/arm/src/stm32/stm32f33xxx_dma.c
@@ -184,16 +184,21 @@ static inline void dmachan_putreg(struct stm32_dma_s *dmach, uint32_t offset, ui
 
 static void stm32_dmatake(FAR struct stm32_dma_s *dmach)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&dmach->sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if the wait was awakened
-       * by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&dmach->sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void stm32_dmagive(FAR struct stm32_dma_s *dmach)
diff --git a/arch/arm/src/stm32/stm32f40xxx_dma.c b/arch/arm/src/stm32/stm32f40xxx_dma.c
index 2ac7903300..6dedd5a337 100644
--- a/arch/arm/src/stm32/stm32f40xxx_dma.c
+++ b/arch/arm/src/stm32/stm32f40xxx_dma.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/stm32/stm32f40xxx_dma.c
  *
- *   Copyright (C) 2011-2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011-2013, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -252,16 +252,21 @@ static inline void dmast_putreg(struct stm32_dma_s *dmast, uint32_t offset, uint
 
 static void stm32_dmatake(FAR struct stm32_dma_s *dmast)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&dmast->sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if the wait was awakened
-       * by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&dmast->sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void stm32_dmagive(FAR struct stm32_dma_s *dmast)
diff --git a/arch/arm/src/stm32/stm32f40xxx_i2c.c b/arch/arm/src/stm32/stm32f40xxx_i2c.c
index 97a08e5f3a..195c9cc596 100644
--- a/arch/arm/src/stm32/stm32f40xxx_i2c.c
+++ b/arch/arm/src/stm32/stm32f40xxx_i2c.c
@@ -561,10 +561,21 @@ static inline void stm32_i2c_modifyreg(FAR struct stm32_i2c_priv_s *priv,
 
 static inline void stm32_i2c_sem_wait(FAR struct stm32_i2c_priv_s *priv)
 {
-  while (sem_wait(&priv->sem_excl) != 0)
+  int ret;
+
+  do
     {
-      DEBUGASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->sem_excl);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /************************************************************************************
diff --git a/arch/arm/src/stm32f0/stm32f0_i2c.c b/arch/arm/src/stm32f0/stm32f0_i2c.c
index 8a6a1ab40d..8e83bedf79 100644
--- a/arch/arm/src/stm32f0/stm32f0_i2c.c
+++ b/arch/arm/src/stm32f0/stm32f0_i2c.c
@@ -456,10 +456,21 @@ static inline void stm32f0_i2c_modifyreg32(FAR struct stm32f0_i2c_priv_s *priv,
 
 static inline void stm32f0_i2c_sem_wait(FAR struct stm32f0_i2c_priv_s *priv)
 {
-  while (sem_wait(&priv->sem_excl) != 0)
+  int ret;
+
+  do
     {
-      ASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->sem_excl);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /************************************************************************************
diff --git a/arch/arm/src/stm32f7/stm32_bbsram.c b/arch/arm/src/stm32f7/stm32_bbsram.c
index 3ec3875736..6a1466ea1b 100644
--- a/arch/arm/src/stm32f7/stm32_bbsram.c
+++ b/arch/arm/src/stm32f7/stm32_bbsram.c
@@ -234,10 +234,10 @@ static void stm32_bbsram_semtake(FAR struct stm32_bbsram_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->exclsem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(&priv->exclsem);
+      DEBUGASSERT(ret == 0 || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/stm32f7/stm32_dma.c b/arch/arm/src/stm32f7/stm32_dma.c
index e44586d7c0..4dc26358dd 100644
--- a/arch/arm/src/stm32f7/stm32_dma.c
+++ b/arch/arm/src/stm32f7/stm32_dma.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/stm32f7/stm32_dma.c
  *
- *   Copyright (C) 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -252,16 +252,21 @@ static inline void dmast_putreg(struct stm32_dma_s *dmast, uint32_t offset, uint
 
 static void stm32_dmatake(FAR struct stm32_dma_s *dmast)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&dmast->sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if the wait was awakened
-       * by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&dmast->sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void stm32_dmagive(FAR struct stm32_dma_s *dmast)
diff --git a/arch/arm/src/stm32f7/stm32_dma2d.c b/arch/arm/src/stm32f7/stm32_dma2d.c
index fa41425326..58b7e3d242 100644
--- a/arch/arm/src/stm32f7/stm32_dma2d.c
+++ b/arch/arm/src/stm32f7/stm32_dma2d.c
@@ -501,15 +501,15 @@ static int stm32_dma2d_waitforirq(void)
 
       priv->wait = true;
 
-      ret = sem_wait(priv->sem);
+      ret = nxsem_wait(priv->sem);
 
       /* irq or an error occurs, reset the wait flag */
 
       priv->wait = false;
 
-      if (ret != OK)
+      if (ret < 0)
         {
-          lcderr("ERROR: sem_wait() failed\n");
+          lcderr("ERROR: nxsem_wait() failed\n");
           return ret;
         }
     }
@@ -1172,7 +1172,7 @@ static int stm32_dma2dgetvideoinfo(FAR struct dma2d_layer_s *layer,
 
   if (stm32_dma2d_lvalidate(priv) && vinfo)
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
       memcpy(vinfo, &priv->vinfo, sizeof(struct fb_videoinfo_s));
       nxsem_post(priv->lock);
 
@@ -1209,7 +1209,7 @@ static int stm32_dma2dgetplaneinfo(FAR struct dma2d_layer_s *layer, int planeno,
 
   if (stm32_dma2d_lvalidate(priv) && pinfo && planeno == 0)
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
       memcpy(pinfo, &priv->pinfo, sizeof(struct fb_planeinfo_s));
       nxsem_post(priv->lock);
 
@@ -1244,7 +1244,7 @@ static int stm32_dma2dgetlid(FAR struct dma2d_layer_s *layer, int *lid)
 
   if (stm32_dma2d_lvalidate(priv) && lid)
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
       *lid = priv->lid;
       nxsem_post(priv->lock);
       return OK;
@@ -1282,7 +1282,7 @@ static int stm32_dma2dsetclut(FAR struct dma2d_layer_s *layer,
 
   if (stm32_dma2d_lvalidate(priv) && cmap)
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
 
 #ifdef CONFIG_STM32F7_LTDC_INTERFACE
       if (priv->lid < DMA2D_SHADOW_LAYER)
@@ -1401,7 +1401,7 @@ static int stm32_dma2dgetclut(FAR struct dma2d_layer_s *layer,
 
   if (stm32_dma2d_lvalidate(priv) && cmap)
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
 
       if (priv->fmt != DMA2D_PF_L8)
         {
@@ -1491,7 +1491,7 @@ static int stm32_dma2dsetalpha(FAR struct dma2d_layer_s *layer, uint8_t alpha)
 
   if (stm32_dma2d_lvalidate(priv))
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
       priv->alpha = alpha;
       nxsem_post(priv->lock);
 
@@ -1526,7 +1526,7 @@ static int stm32_dma2dgetalpha(FAR struct dma2d_layer_s *layer, uint8_t *alpha)
 
   if (stm32_dma2d_lvalidate(priv))
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
       *alpha = priv->alpha;
       nxsem_post(priv->lock);
 
@@ -1577,7 +1577,7 @@ static int stm32_dma2dsetblendmode(FAR struct dma2d_layer_s *layer,
 
   if (stm32_dma2d_lvalidate(priv))
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
       priv->blendmode = mode;
       nxsem_post(priv->lock);
 
@@ -1613,7 +1613,7 @@ static int stm32_dma2dgetblendmode(FAR struct dma2d_layer_s *layer,
 
   if (stm32_dma2d_lvalidate(priv) && mode)
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
       *mode = priv->blendmode;
       nxsem_post(priv->lock);
 
@@ -1664,7 +1664,7 @@ static int stm32_dma2dblit(FAR struct dma2d_layer_s *dest,
         stm32_dma2d_lvalidatesize(srclayer, srcarea->xpos,
                                     srcarea->ypos, srcarea))
     {
-      sem_wait(destlayer->lock);
+      nxsem_wait(destlayer->lock);
 
       /* Set output pfc */
 
@@ -1778,8 +1778,7 @@ static int stm32_dma2dblend(FAR struct dma2d_layer_s *dest,
             stm32_dma2d_lvalidatesize(backlayer, backarea->xpos,
                                         backarea->ypos, backarea))
     {
-
-      sem_wait(destlayer->lock);
+      nxsem_wait(destlayer->lock);
 
       /* Set output pfc */
 
@@ -1874,8 +1873,7 @@ static int stm32_dma2dfillarea(FAR struct dma2d_layer_s *layer,
 
   if (stm32_dma2d_lvalidatesize(priv, area->xpos, area->ypos, area))
     {
-
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
 
       /* Set output pfc */
 
@@ -1943,7 +1941,7 @@ FAR struct dma2d_layer_s *up_dma2dgetlayer(int lid)
   if (lid < DMA2D_LAYER_NSIZE)
     {
       FAR struct stm32_dma2d_s *priv;
-      sem_wait(&g_lock);
+      nxsem_wait(&g_lock);
       priv = g_layers[lid];
       nxsem_post(&g_lock);
 
@@ -1994,7 +1992,7 @@ FAR struct dma2d_layer_s *up_dma2dcreatelayer(fb_coord_t width,
 
   ret = stm32_dma2d_bpp(fmt, &bpp);
 
-  sem_wait(&g_lock);
+  nxsem_wait(&g_lock);
 
   /* Get a free layer identifier */
 
@@ -2100,7 +2098,7 @@ int up_dma2dremovelayer(FAR struct dma2d_layer_s *layer)
 
   if (stm32_dma2d_lvalidate(priv) && priv->lid >= DMA2D_SHADOW_LAYER)
     {
-      sem_wait(priv->lock);
+      nxsem_wait(priv->lock);
 
       /* Check also if the layer id is valid to the layer reference */
 
diff --git a/arch/arm/src/stm32f7/stm32_i2c.c b/arch/arm/src/stm32f7/stm32_i2c.c
index c18772041b..09f7bdcefa 100644
--- a/arch/arm/src/stm32f7/stm32_i2c.c
+++ b/arch/arm/src/stm32f7/stm32_i2c.c
@@ -714,10 +714,21 @@ static inline void stm32_i2c_modifyreg32(FAR struct stm32_i2c_priv_s *priv,
 
 static inline void stm32_i2c_sem_wait(FAR struct i2c_master_s *dev)
 {
-  while (sem_wait(&((struct stm32_i2c_inst_s *)dev)->priv->sem_excl) != 0)
+  int ret;
+
+  do
     {
-      ASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&((struct stm32_i2c_inst_s *)dev)->priv->sem_excl);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /************************************************************************************
diff --git a/arch/arm/src/stm32f7/stm32_ltdc.c b/arch/arm/src/stm32f7/stm32_ltdc.c
index 07e7af8767..c979cc22e3 100644
--- a/arch/arm/src/stm32f7/stm32_ltdc.c
+++ b/arch/arm/src/stm32f7/stm32_ltdc.c
@@ -1193,15 +1193,15 @@ static int stm32_ltdc_waitforirq(void)
 
       priv->wait = true;
 
-      ret = sem_wait(priv->sem);
+      ret = nxsem_wait(priv->sem);
 
       /* irq or an error occurs, reset the wait flag */
 
       priv->wait = false;
 
-      if (ret != OK)
+      if (ret < 0)
         {
-          lcderr("ERROR: sem_wait() failed\n");
+          lcderr("ERROR: nxsem_wait() failed\n");
         }
     }
 
@@ -2394,7 +2394,7 @@ static int stm32_setclut(struct ltdc_layer_s *layer,
 
   if (stm32_ltdc_lvalidate(priv) && cmap)
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
 
       if (priv->state.vinfo.fmt != FB_FMT_RGB8)
         {
@@ -2453,7 +2453,7 @@ static int stm32_getclut(struct ltdc_layer_s *layer,
 
   if (priv == &LAYER_L1 || priv == &LAYER_L2)
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
 #ifdef CONFIG_STM32F7_DMA2D
       /* Note! We share the same color lookup table with the dma2d driver and
        * the getclut implementation works in the same way.
@@ -2553,7 +2553,7 @@ static int stm32_getlid(FAR struct ltdc_layer_s *layer, int *lid,
     {
       int   ret = OK;
 
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
 
       switch (flag)
         {
@@ -2627,7 +2627,7 @@ static int stm32_setcolor(FAR struct ltdc_layer_s *layer, uint32_t argb)
 
   if (stm32_ltdc_lvalidate(priv))
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       priv->state.color = argb;
       priv->operation |= LTDC_LAYER_SETCOLOR;
       nxsem_post(priv->state.lock);
@@ -2663,7 +2663,7 @@ static int stm32_getcolor(FAR struct ltdc_layer_s *layer, uint32_t *argb)
 
   if (stm32_ltdc_lvalidate(priv))
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       *argb = priv->state.color;
       nxsem_post(priv->state.lock);
 
@@ -2700,7 +2700,7 @@ static int stm32_setcolorkey(FAR struct ltdc_layer_s *layer, uint32_t rgb)
 
   if (stm32_ltdc_lvalidate(priv))
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       priv->state.colorkey = rgb;
       priv->operation |= LTDC_LAYER_SETCOLORKEY;
       nxsem_post(priv->state.lock);
@@ -2736,7 +2736,7 @@ static int stm32_getcolorkey(FAR struct ltdc_layer_s *layer, uint32_t *rgb)
 
   if (stm32_ltdc_lvalidate(priv))
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       *rgb = priv->state.colorkey;
       nxsem_post(priv->state.lock);
 
@@ -2777,7 +2777,7 @@ static int stm32_setalpha(FAR struct ltdc_layer_s *layer, uint8_t alpha)
 
   if (stm32_ltdc_lvalidate(priv))
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       priv->state.alpha = alpha;
       priv->operation  |= LTDC_LAYER_SETALPHAVALUE;
       nxsem_post(priv->state.lock);
@@ -2813,7 +2813,7 @@ static int stm32_getalpha(FAR struct ltdc_layer_s *layer, uint8_t *alpha)
 
   if (stm32_ltdc_lvalidate(priv))
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       *alpha = priv->state.alpha;
       nxsem_post(priv->state.lock);
 
@@ -2875,7 +2875,7 @@ static int stm32_setblendmode(FAR struct ltdc_layer_s *layer, uint32_t mode)
     {
       int         ret = OK;
 
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
 
       /* Disable colorkeying by default */
 
@@ -2981,7 +2981,7 @@ static int stm32_getblendmode(FAR struct ltdc_layer_s *layer, uint32_t *mode)
 
   if (stm32_ltdc_lvalidate(priv))
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       *mode = priv->state.blendmode;
       nxsem_post(priv->state.lock);
 
@@ -3032,7 +3032,7 @@ static int stm32_setarea(FAR struct ltdc_layer_s *layer,
     {
       int ret;
 
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
 
       ret = stm32_ltdc_lvalidatearea(priv, area->xpos, area->ypos, area->xres,
                                     area->yres, srcxpos, srcypos);
@@ -3086,7 +3086,7 @@ static int stm32_getarea(FAR struct ltdc_layer_s *layer,
 
   if (stm32_ltdc_lvalidate(priv))
     {
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       *srcxpos = priv->state.xpos;
       *srcypos = priv->state.ypos;
       memcpy(area, &priv->state.area, sizeof(struct ltdc_area_s));
@@ -3155,7 +3155,7 @@ static int stm32_update(FAR struct ltdc_layer_s *layer, uint32_t mode)
       bool    waitvblank = false;
       uint8_t reload = LTDC_SRCR_IMR;
 
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
 
       if (mode & LTDC_SYNC_VBLANK)
         {
@@ -3294,7 +3294,7 @@ static int stm32_blit(FAR struct ltdc_layer_s *dest,
     {
       int   ret;
 
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       ret = priv->dma2d->blit(priv->dma2d, destxpos, destypos, src, srcarea);
       nxsem_post(priv->state.lock);
 
@@ -3349,7 +3349,7 @@ static int stm32_blend(FAR struct ltdc_layer_s *dest,
     {
       int   ret;
 
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       ret = priv->dma2d->blend(priv->dma2d, destxpos, destypos,
                                fore, forexpos, foreypos, back, backarea);
       nxsem_post(priv->state.lock);
@@ -3392,7 +3392,7 @@ static int stm32_fillarea(FAR struct ltdc_layer_s *layer,
     {
       int   ret;
 
-      sem_wait(priv->state.lock);
+      nxsem_wait(priv->state.lock);
       ret = priv->dma2d->fillarea(priv->dma2d, area, color);
       nxsem_post(priv->state.lock);
 
diff --git a/arch/arm/src/stm32f7/stm32_otghost.c b/arch/arm/src/stm32f7/stm32_otghost.c
index c59c60d31c..a8a3511d13 100644
--- a/arch/arm/src/stm32f7/stm32_otghost.c
+++ b/arch/arm/src/stm32f7/stm32_otghost.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/stm32f7/stm32_otghost.c
  *
- *   Copyright (C) 2012-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *            David Sidrane <david_s5@nscdg.com>
  *
@@ -643,16 +643,21 @@ static inline void stm32_modifyreg(uint32_t addr, uint32_t clrbits,
 
 static void stm32_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
@@ -1104,13 +1109,13 @@ static int stm32_chan_wait(FAR struct stm32_usbhost_s *priv,
        * wait here.
        */
 
-      ret = sem_wait(&chan->waitsem);
+      ret = nxsem_wait(&chan->waitsem);
 
-      /* sem_wait should succeed.  But it is possible that we could be
+      /* nxsem_wait should succeed.  But it is possible that we could be
        * awakened by a signal too.
        */
 
-      DEBUGASSERT(ret == OK || get_errno() == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
   while (chan->waiter);
 
diff --git a/arch/arm/src/stm32f7/stm32_rng.c b/arch/arm/src/stm32f7/stm32_rng.c
index 63ef4b4ad0..854b5ba276 100644
--- a/arch/arm/src/stm32f7/stm32_rng.c
+++ b/arch/arm/src/stm32f7/stm32_rng.c
@@ -269,48 +269,42 @@ static ssize_t stm32_rngread(struct file *filep, char *buffer, size_t buflen)
 {
   int ret;
 
-  if (sem_wait(&g_rngdev.rd_devsem) < 0)
+  ret = nxsem_wait(&g_rngdev.rd_devsem);
+  if (ret < 0)
     {
-      return -get_errno();
+      return ret;
     }
-  else
-    {
-      /* We've got the device semaphore, proceed with reading */
 
-      /* Initialize the operation semaphore with 0 for blocking until the
-       * buffer is filled from interrupts.  The readsem semaphore is used
-       * for signaling and, hence, should not have priority inheritance
-       * enabled.
-       */
+  /* We've got the device semaphore, proceed with reading */
 
-      nxsem_init(&g_rngdev.rd_readsem, 0, 0);
-      nxsem_setprotocol(&g_rngdev.rd_readsem, SEM_PRIO_NONE);
+  /* Initialize the operation semaphore with 0 for blocking until the
+   * buffer is filled from interrupts.  The readsem semaphore is used
+   * for signaling and, hence, should not have priority inheritance
+   * enabled.
+   */
 
-      g_rngdev.rd_buflen = buflen;
-      g_rngdev.rd_buf = buffer;
+  nxsem_init(&g_rngdev.rd_readsem, 0, 0);
+  nxsem_setprotocol(&g_rngdev.rd_readsem, SEM_PRIO_NONE);
 
-      /* Enable RNG with interrupts */
+  g_rngdev.rd_buflen = buflen;
+  g_rngdev.rd_buf = buffer;
 
-      stm32_rngenable();
+  /* Enable RNG with interrupts */
 
-      /* Wait until the buffer is filled */
+  stm32_rngenable();
 
-      ret = sem_wait(&g_rngdev.rd_readsem);
-      if (ret < 0)
-        {
-          ret = -get_errno();
-        }
+  /* Wait until the buffer is filled */
 
-      /* Done with the operation semaphore */
+  ret = nxsem_wait(&g_rngdev.rd_readsem);
 
-      nxsem_destroy(&g_rngdev.rd_readsem);
+  /* Done with the operation semaphore */
 
-      /* Free RNG via the device semaphore for next use */
+  nxsem_destroy(&g_rngdev.rd_readsem);
 
-      nxsem_post(&g_rngdev.rd_devsem);
+  /* Free RNG via the device semaphore for next use */
 
-      return ret < 0 ? ret : buflen;
-    }
+  nxsem_post(&g_rngdev.rd_devsem);
+  return ret < 0 ? ret : buflen;
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/stm32f7/stm32_sdmmc.c b/arch/arm/src/stm32f7/stm32_sdmmc.c
index fe8862ebb2..e6168ad663 100644
--- a/arch/arm/src/stm32f7/stm32_sdmmc.c
+++ b/arch/arm/src/stm32f7/stm32_sdmmc.c
@@ -727,16 +727,21 @@ static inline void sdmmc_modifyreg32(struct stm32_dev_s *priv, int offset,
 
 static void stm32_takesem(struct stm32_dev_s *priv)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&priv->waitsem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->waitsem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/stm32f7/stm32_spi.c b/arch/arm/src/stm32f7/stm32_spi.c
index 24c8f6bc47..8ddf22bd3a 100644
--- a/arch/arm/src/stm32f7/stm32_spi.c
+++ b/arch/arm/src/stm32f7/stm32_spi.c
@@ -1,7 +1,7 @@
 /************************************************************************************
  * arm/arm/src/stm32f7/stm32_spi.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *            David Sidrane <david_s5@nscdg.com>
  *
@@ -706,18 +706,23 @@ static inline bool spi_9to16bitmode(FAR struct stm32_spidev_s *priv)
 #ifdef CONFIG_STM32F7_SPI_DMA
 static void spi_dmarxwait(FAR struct stm32_spidev_s *priv)
 {
+  int ret;
+
   /* Take the semaphore (perhaps waiting).  If the result is zero, then the DMA
    * must not really have completed???
    */
 
-  while (sem_wait(&priv->rxsem) != 0 || priv->rxresult == 0)
+  do
     {
-      /* The only case that an error should occur here is if the wait was awakened
-       * by a signal.
+      ret = nxsem_wait(&priv->rxsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR || priv->rxresult == 0);
 }
 #endif
 
@@ -732,18 +737,23 @@ static void spi_dmarxwait(FAR struct stm32_spidev_s *priv)
 #ifdef CONFIG_STM32F7_SPI_DMA
 static void spi_dmatxwait(FAR struct stm32_spidev_s *priv)
 {
+  int ret;
+
   /* Take the semaphore (perhaps waiting).  If the result is zero, then the DMA
    * must not really have completed???
    */
 
-  while (sem_wait(&priv->txsem) != 0 || priv->txresult == 0)
+  do
     {
-      /* The only case that an error should occur here is if the wait was awakened
-       * by a signal.
+      ret = nxsem_wait(&priv->txsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR || priv->txresult == 0);
 }
 #endif
 
@@ -1025,26 +1035,31 @@ static void spi_modifycr2(FAR struct stm32_spidev_s *priv, uint16_t setbits,
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct stm32_spidev_s *priv = (FAR struct stm32_spidev_s *)dev;
+  int ret;
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /************************************************************************************
diff --git a/arch/arm/src/stm32l4/stm32l4_flash.c b/arch/arm/src/stm32l4/stm32l4_flash.c
index 2e312f20fa..fdafc0c7ec 100644
--- a/arch/arm/src/stm32l4/stm32l4_flash.c
+++ b/arch/arm/src/stm32l4/stm32l4_flash.c
@@ -102,10 +102,21 @@ static sem_t g_sem = SEM_INITIALIZER(1);
 
 static inline void sem_lock(void)
 {
-  while (sem_wait(&g_sem) < 0)
+  int ret;
+
+  do
     {
-      DEBUGASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&g_sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void sem_unlock(void)
diff --git a/arch/arm/src/stm32l4/stm32l4_i2c.c b/arch/arm/src/stm32l4/stm32l4_i2c.c
index 326646bf43..1f46b166e5 100644
--- a/arch/arm/src/stm32l4/stm32l4_i2c.c
+++ b/arch/arm/src/stm32l4/stm32l4_i2c.c
@@ -488,10 +488,21 @@ static inline void stm32l4_i2c_modifyreg32(FAR struct stm32l4_i2c_priv_s *priv,
 
 static inline void stm32l4_i2c_sem_wait(FAR struct stm32l4_i2c_priv_s *priv)
 {
-  while (sem_wait(&priv->sem_excl) != 0)
+  int ret;
+
+  do
     {
-      ASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->sem_excl);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /************************************************************************************
diff --git a/arch/arm/src/stm32l4/stm32l4_otgfshost.c b/arch/arm/src/stm32l4/stm32l4_otgfshost.c
index 84b4296891..77b7b1aaef 100644
--- a/arch/arm/src/stm32l4/stm32l4_otgfshost.c
+++ b/arch/arm/src/stm32l4/stm32l4_otgfshost.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/stm32l4/stm32l4_otgfshost.c
  *
- *   Copyright (C) 2012-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *            dev@ziggurat29.com
  *
@@ -645,16 +645,21 @@ static inline void stm32l4_modifyreg(uint32_t addr, uint32_t clrbits,
 
 static void stm32l4_takesem(FAR sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
@@ -1106,13 +1111,13 @@ static int stm32l4_chan_wait(FAR struct stm32l4_usbhost_s *priv,
        * wait here.
        */
 
-      ret = sem_wait(&chan->waitsem);
+      ret = nxsem_wait(&chan->waitsem);
 
-      /* sem_wait should succeed.  But it is possible that we could be
+      /* nxsem_wait should succeed.  But it is possible that we could be
        * awakened by a signal too.
        */
 
-      DEBUGASSERT(ret == OK || get_errno() == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
   while (chan->waiter);
 
diff --git a/arch/arm/src/stm32l4/stm32l4_qspi.c b/arch/arm/src/stm32l4/stm32l4_qspi.c
index 1381ddce2d..793fbb7ffa 100644
--- a/arch/arm/src/stm32l4/stm32l4_qspi.c
+++ b/arch/arm/src/stm32l4/stm32l4_qspi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/stm32l4/stm32l4_qspi.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: dev@ziggurat29.com
  *
  * Redistribution and use in source and binary forms, with or without
@@ -1435,7 +1435,7 @@ static int qspi_memory_dma(struct stm32l4_qspidev_s *priv,
   qspi_dma_sample(priv, DMA_AFTER_START);
 
   /* Wait for DMA completion.  This is done in a loop because there may be
-   * false alarm semaphore counts that cause sem_wait() not fail to wait
+   * false alarm semaphore counts that cause nxsem_wait() not fail to wait
    * or to wake-up prematurely (for example due to the receipt of a signal).
    * We know that the DMA has completed when the result is anything other
    * that -EBUSY.
@@ -1454,7 +1454,7 @@ static int qspi_memory_dma(struct stm32l4_qspidev_s *priv,
 
       /* Wait for the DMA complete */
 
-      ret = sem_wait(&priv->dmawait);
+      ret = nxsem_wait(&priv->dmawait);
 
       /* Cancel the watchdog timeout */
 
@@ -1468,14 +1468,13 @@ static int qspi_memory_dma(struct stm32l4_qspidev_s *priv,
            * was awakened by a signal.
            */
 
-          int errorcode = errno;
-          if (errorcode != EINTR)
+          if (ret != -EINTR)
             {
               DEBUGPANIC();
               regval = qspi_getreg(priv, STM32L4_QUADSPI_CR_OFFSET);
               regval &= ~QSPI_CR_DMAEN;
               qspi_putreg(priv, regval, STM32L4_QUADSPI_CR_OFFSET);
-              return -errorcode;
+              return ret;
             }
         }
 
@@ -1681,27 +1680,32 @@ static int qspi_transmit_blocking(struct stm32l4_qspidev_s *priv,
 static int qspi_lock(struct qspi_dev_s *dev, bool lock)
 {
   struct stm32l4_qspidev_s *priv = (struct stm32l4_qspidev_s *)dev;
+  int ret;
 
   spiinfo("lock=%d\n", lock);
   if (lock)
     {
-      /* Take the semaphore (perhaps waiting) */
+          /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
+          ret = nxsem_wait(&priv->exclsem);
+
           /* The only case that an error should occur here is if the wait
            * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
@@ -2029,7 +2033,7 @@ static int qspi_command(struct qspi_dev_s *dev,
 
   /* Wait for the interrupt routine to finish it's magic */
 
-  sem_wait(&priv->op_sem);
+  (void)nxsem_wait(&priv->op_sem);
   MEMORY_SYNC();
 
   /* Convey the result */
@@ -2187,7 +2191,7 @@ static int qspi_memory(struct qspi_dev_s *dev,
 
   /* Wait for the interrupt routine to finish it's magic */
 
-  sem_wait(&priv->op_sem);
+  (void)nxsem_wait(&priv->op_sem);
   MEMORY_SYNC();
 
   /* convey the result */
diff --git a/arch/arm/src/stm32l4/stm32l4_rng.c b/arch/arm/src/stm32l4/stm32l4_rng.c
index f919904bae..cb5a8ce2ab 100644
--- a/arch/arm/src/stm32l4/stm32l4_rng.c
+++ b/arch/arm/src/stm32l4/stm32l4_rng.c
@@ -252,44 +252,44 @@ static int stm32l4_rnginterrupt(int irq, void *context, FAR void *arg)
 
 static ssize_t stm32l4_rngread(struct file *filep, char *buffer, size_t buflen)
 {
-  if (sem_wait(&g_rngdev.rd_devsem) != OK)
+  int ret;
+
+  ret = nxsem_wait(&g_rngdev.rd_devsem);
+  if (ret < 0)
     {
-      return -errno;
+      return ret;
     }
-  else
-    {
-      /* We've got the device semaphore, proceed with reading */
 
-      /* Initialize the operation semaphore with 0 for blocking until the
-       * buffer is filled from interrupts.  The readsem semaphore is used
-       * for signaling and, hence, should not have priority inheritance
-       * enabled.
-       */
+  /* We've got the device semaphore, proceed with reading */
 
-      nxsem_init(&g_rngdev.rd_readsem, 0, 0);
-      nxsem_setprotocol(&g_rngdev.rd_readsem, SEM_PRIO_NONE);
+  /* Initialize the operation semaphore with 0 for blocking until the
+   * buffer is filled from interrupts.  The readsem semaphore is used
+   * for signaling and, hence, should not have priority inheritance
+   * enabled.
+   */
 
-      g_rngdev.rd_buflen = buflen;
-      g_rngdev.rd_buf = buffer;
+  nxsem_init(&g_rngdev.rd_readsem, 0, 0);
+  nxsem_setprotocol(&g_rngdev.rd_readsem, SEM_PRIO_NONE);
 
-      /* Enable RNG with interrupts */
+  g_rngdev.rd_buflen = buflen;
+  g_rngdev.rd_buf = buffer;
 
-      stm32l4_rngenable();
+  /* Enable RNG with interrupts */
 
-      /* Wait until the buffer is filled */
+  stm32l4_rngenable();
 
-      sem_wait(&g_rngdev.rd_readsem);
+  /* Wait until the buffer is filled */
 
-      /* Done with the operation semaphore */
+  nxsem_wait(&g_rngdev.rd_readsem);
 
-      nxsem_destroy(&g_rngdev.rd_readsem);
+  /* Done with the operation semaphore */
 
-      /* Free RNG via the device semaphore for next use */
+  nxsem_destroy(&g_rngdev.rd_readsem);
 
-      nxsem_post(&g_rngdev.rd_devsem);
+  /* Free RNG via the device semaphore for next use */
 
-      return buflen;
-    }
+  nxsem_post(&g_rngdev.rd_devsem);
+  return buflen;
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/stm32l4/stm32l4_rtc_lowerhalf.c b/arch/arm/src/stm32l4/stm32l4_rtc_lowerhalf.c
index 0ce0fd4f47..69a357b991 100644
--- a/arch/arm/src/stm32l4/stm32l4_rtc_lowerhalf.c
+++ b/arch/arm/src/stm32l4/stm32l4_rtc_lowerhalf.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/stm32l4/stm32l4_rtc_lowerhalf.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *           dev@ziggurat29.com (adaptations for stm32l4)
  *
@@ -228,9 +228,10 @@ static int stm32l4_rdtime(FAR struct rtc_lowerhalf_s *lower,
 
   priv = (FAR struct stm32l4_lowerhalf_s *)lower;
 
-  if (sem_wait(&priv->devsem) != OK)
+  ret = nxsem_wait(&priv->devsem);
+  if (ret < 0)
    {
-     return -errno;
+     return ret;
    }
 
   /* This operation depends on the fact that struct rtc_time is cast
@@ -268,9 +269,10 @@ static int stm32l4_settime(FAR struct rtc_lowerhalf_s *lower,
 
   priv = (FAR struct stm32l4_lowerhalf_s *)lower;
 
-  if (sem_wait(&priv->devsem) != OK)
+  ret = nxsem_wait(&priv->devsem);
+  if (ret < 0)
    {
-     return -errno;
+     return ret;
    }
 
    /* This operation depends on the fact that struct rtc_time is cast
@@ -327,7 +329,7 @@ static int stm32l4_setalarm(FAR struct rtc_lowerhalf_s *lower,
   FAR struct stm32l4_lowerhalf_s *priv;
   FAR struct stm32l4_cbinfo_s *cbinfo;
   struct alm_setalarm_s lowerinfo;
-  int ret = -EINVAL;
+  int ret;
 
   /* ID0-> Alarm A; ID1 -> Alarm B */
 
@@ -335,11 +337,13 @@ static int stm32l4_setalarm(FAR struct rtc_lowerhalf_s *lower,
   DEBUGASSERT(alarminfo->id == RTC_ALARMA || alarminfo->id == RTC_ALARMB);
   priv = (FAR struct stm32l4_lowerhalf_s *)lower;
 
-  if (sem_wait(&priv->devsem) != OK)
+  ret = nxsem_wait(&priv->devsem);
+  if (ret < 0)
    {
-     return -errno;
+     return ret;
    }
 
+  ret = -EINVAL;
   if (alarminfo->id == RTC_ALARMA || alarminfo->id == RTC_ALARMB)
     {
       /* Remember the callback information */
@@ -467,19 +471,21 @@ static int stm32l4_cancelalarm(FAR struct rtc_lowerhalf_s *lower, int alarmid)
 {
   FAR struct stm32l4_lowerhalf_s *priv;
   FAR struct stm32l4_cbinfo_s *cbinfo;
-  int ret = -EINVAL;
+  int ret;
 
   DEBUGASSERT(lower != NULL);
   DEBUGASSERT(alarmid == RTC_ALARMA || alarmid == RTC_ALARMB);
   priv = (FAR struct stm32l4_lowerhalf_s *)lower;
 
-  if (sem_wait(&priv->devsem) != OK)
+  ret = nxsem_wait(&priv->devsem);
+  if (ret < 0)
    {
-     return -errno;
+     return ret;
    }
 
   /* ID0-> Alarm A; ID1 -> Alarm B */
 
+  ret = -EINVAL;
   if (alarmid == RTC_ALARMA || alarmid == RTC_ALARMB)
     {
       /* Nullify callback information to reduce window for race conditions */
diff --git a/arch/arm/src/stm32l4/stm32l4_sai.c b/arch/arm/src/stm32l4/stm32l4_sai.c
index 8f20de6f59..80d07f024f 100644
--- a/arch/arm/src/stm32l4/stm32l4_sai.c
+++ b/arch/arm/src/stm32l4/stm32l4_sai.c
@@ -466,10 +466,10 @@ static void sai_exclsem_take(struct stm32l4_sai_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->exclsem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(&priv->exclsem);
+      DEBUGASSERT(ret == 0 || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
@@ -1166,10 +1166,10 @@ static void sai_bufsem_take(struct stm32l4_sai_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->bufsem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(&priv->bufsem);
+      DEBUGASSERT(ret == 0 || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/stm32l4/stm32l4_sdmmc.c b/arch/arm/src/stm32l4/stm32l4_sdmmc.c
index e0f2179b24..6da267d2d0 100644
--- a/arch/arm/src/stm32l4/stm32l4_sdmmc.c
+++ b/arch/arm/src/stm32l4/stm32l4_sdmmc.c
@@ -726,16 +726,21 @@ static inline void sdmmc_modifyreg32(struct stm32_dev_s *priv, int offset,
 
 static void stm32_takesem(struct stm32_dev_s *priv)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&priv->waitsem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if the wait was
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->waitsem);
+
+      /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/stm32l4/stm32l4_spi.c b/arch/arm/src/stm32l4/stm32l4_spi.c
index a1dc5430de..7f5d1543a1 100644
--- a/arch/arm/src/stm32l4/stm32l4_spi.c
+++ b/arch/arm/src/stm32l4/stm32l4_spi.c
@@ -576,18 +576,23 @@ static inline bool spi_16bitmode(FAR struct stm32l4_spidev_s *priv)
 #ifdef CONFIG_STM32L4_SPI_DMA
 static void spi_dmarxwait(FAR struct stm32l4_spidev_s *priv)
 {
+  int ret;
+
   /* Take the semaphore (perhaps waiting).  If the result is zero, then the DMA
    * must not really have completed???
    */
 
-  while (sem_wait(&priv->rxsem) != 0 || priv->rxresult == 0)
+  do
     {
-      /* The only case that an error should occur here is if the wait was awakened
-       * by a signal.
+      ret = nxsem_wait(&priv->rxsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR || priv->rxresult == 0);
 }
 #endif
 
@@ -602,18 +607,23 @@ static void spi_dmarxwait(FAR struct stm32l4_spidev_s *priv)
 #ifdef CONFIG_STM32L4_SPI_DMA
 static void spi_dmatxwait(FAR struct stm32l4_spidev_s *priv)
 {
+  int ret;
+
   /* Take the semaphore (perhaps waiting).  If the result is zero, then the DMA
    * must not really have completed???
    */
 
-  while (sem_wait(&priv->txsem) != 0 || priv->txresult == 0)
+  do
     {
-      /* The only case that an error should occur here is if the wait was awakened
-       * by a signal.
+      ret = nxsem_wait(&priv->txsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR || priv->txresult == 0);
 }
 #endif
 
@@ -870,25 +880,31 @@ static void spi_modifycr(uint32_t addr, FAR struct stm32l4_spidev_s *priv,
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct stm32l4_spidev_s *priv = (FAR struct stm32l4_spidev_s *)dev;
+  int ret;
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
-  return OK;
+
+  return ret;
 }
 
 /************************************************************************************
diff --git a/arch/arm/src/stm32l4/stm32l4x6xx_dma.c b/arch/arm/src/stm32l4/stm32l4x6xx_dma.c
index bfa0228f46..cd194b2cba 100644
--- a/arch/arm/src/stm32l4/stm32l4x6xx_dma.c
+++ b/arch/arm/src/stm32l4/stm32l4x6xx_dma.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/stm32l4/stm32l4x6xx_dma.c
  *
- *   Copyright (C) 2009, 2011-2013 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2009, 2011-2013, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *           Sebastien Lorquet <sebastien@lorquet.fr>
  *           dev@ziggurat29.com
@@ -223,16 +223,21 @@ static inline void dmachan_putreg(struct stm32l4_dma_s *dmach, uint32_t offset,
 
 static void stm32l4_dmatake(FAR struct stm32l4_dma_s *dmach)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&dmach->sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if the wait was awakened
-       * by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&dmach->sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void stm32l4_dmagive(FAR struct stm32l4_dma_s *dmach)
diff --git a/arch/arm/src/tiva/tiva_adclow.c b/arch/arm/src/tiva/tiva_adclow.c
index f698453f89..5519c18039 100644
--- a/arch/arm/src/tiva/tiva_adclow.c
+++ b/arch/arm/src/tiva/tiva_adclow.c
@@ -955,23 +955,24 @@ void tiva_adc_lock(FAR struct tiva_adc_s *priv, int sse)
 
   do
     {
-      ret = sem_wait(&s->exclsem);
+      ret = nxsem_wait(&s->exclsem);
 
       /* This should only fail if the wait was canceled by an signal (and the
        * worker thread will receive a lot of signals).
        */
 
-      DEBUGASSERT(ret == OK || errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
 
 #ifdef CONFIG_DEBUG_ANALOG
       if (loop_count % 1000)
         {
           ainfo("loop=%d\n");
         }
+
       ++loop_count;
 #endif
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/arch/arm/src/tiva/tiva_i2c.c b/arch/arm/src/tiva/tiva_i2c.c
index b871d76205..511f12fa07 100644
--- a/arch/arm/src/tiva/tiva_i2c.c
+++ b/arch/arm/src/tiva/tiva_i2c.c
@@ -646,10 +646,21 @@ static inline void tiva_i2c_putreg(struct tiva_i2c_priv_s *priv,
 
 static inline void tiva_i2c_sem_wait(struct tiva_i2c_priv_s *priv)
 {
-  while (sem_wait(&priv->exclsem) != 0)
+  int ret;
+
+  do
     {
-      ASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->exclsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /************************************************************************************
diff --git a/arch/arm/src/tiva/tiva_ssi.c b/arch/arm/src/tiva/tiva_ssi.c
index c805d26183..bd224363b0 100644
--- a/arch/arm/src/tiva/tiva_ssi.c
+++ b/arch/arm/src/tiva/tiva_ssi.c
@@ -507,10 +507,10 @@ static void ssi_semtake(sem_t *sem)
   int ret;
   do
     {
-      ret = sem_wait(sem);
+      ret = nxsem_wait(sem);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
-  while (ret < 0 && errno == EINTR);
-  DEBUGASSERT(ret == 0);
+  while (ret == -EINTR);
 }
 #endif
 
@@ -1084,26 +1084,31 @@ static int ssi_interrupt(int irq, void *context, FAR void *arg)
 static int ssi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct tiva_ssidev_s *priv = (FAR struct tiva_ssidev_s *)dev;
+  int ret;
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/avr/src/avr/up_spi.c b/arch/avr/src/avr/up_spi.c
index 1c3c00d7da..24a4f377cb 100644
--- a/arch/avr/src/avr/up_spi.c
+++ b/arch/avr/src/avr/up_spi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/avr/up_spi.c
  *
- *   Copyright (C) 2011, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -146,25 +146,31 @@ static struct avr_spidev_s g_spidev =
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct avr_spidev_s *priv = (FAR struct avr_spidev_s *)dev;
+  int ret;
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
-  return OK;
+
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/mips/src/pic32mx/pic32mx-spi.c b/arch/mips/src/pic32mx/pic32mx-spi.c
index 1a71acd173..e09688e42c 100644
--- a/arch/mips/src/pic32mx/pic32mx-spi.c
+++ b/arch/mips/src/pic32mx/pic32mx-spi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/mips/src/pic32mx/pic32mx-spi.c
  *
- *   Copyright (C) 2012, 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012, 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -419,25 +419,31 @@ static void spi_putreg(FAR struct pic32mx_dev_s *priv, unsigned int offset,
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct pic32mx_dev_s *priv = (FAR struct pic32mx_dev_s *)dev;
+  int ret;
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
-  return OK;
+
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/mips/src/pic32mz/pic32mz-spi.c b/arch/mips/src/pic32mz/pic32mz-spi.c
index 48f93cb450..287c538b7d 100644
--- a/arch/mips/src/pic32mz/pic32mz-spi.c
+++ b/arch/mips/src/pic32mz/pic32mz-spi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/mips/src/pic32mz/pic32mz-spi.c
  *
- *   Copyright (C) 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -780,25 +780,31 @@ static void spi_exchange16(FAR struct pic32mz_dev_s *priv,
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct pic32mz_dev_s *priv = (FAR struct pic32mz_dev_s *)dev;
+  int ret;
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
-  return OK;
+
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/sim/src/up_touchscreen.c b/arch/sim/src/up_touchscreen.c
index 32c3171e20..49e0954b5c 100644
--- a/arch/sim/src/up_touchscreen.c
+++ b/arch/sim/src/up_touchscreen.c
@@ -311,7 +311,7 @@ static int up_waitsample(FAR struct up_dev_s *priv,
 
       iinfo("Waiting...\n");
       priv->nwaiters++;
-      ret = sem_wait(&priv->waitsem);
+      ret = nxsem_wait(&priv->waitsem);
       priv->nwaiters--;
       iinfo("Awakened...\n");
 
@@ -321,8 +321,7 @@ static int up_waitsample(FAR struct up_dev_s *priv,
            * the failure now.
            */
 
-          DEBUGASSERT(errno == EINTR);
-          ret = -EINTR;
+          DEBUGASSERT(ret == -EINTR);
           goto errout;
         }
     }
@@ -332,7 +331,7 @@ static int up_waitsample(FAR struct up_dev_s *priv,
    * Interrupts and pre-emption will be re-enabled while we wait.
    */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
 
 errout:
   /* Then re-enable interrupts.  We might get interrupt here and there
@@ -407,13 +406,13 @@ static ssize_t up_read(FAR struct file *filep, FAR char *buffer, size_t len)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Try to read sample data. */
@@ -505,13 +504,13 @@ static int up_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Process the IOCTL by command */
@@ -549,13 +548,13 @@ static int up_poll(FAR struct file *filep, FAR struct pollfd *fds,
 
   /* Are we setting up the poll?  Or tearing it down? */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   if (setup)
@@ -718,15 +717,15 @@ void sim_tsc_uninitialize(void)
 
   do
     {
-      ret = sem_wait(&priv->devsem);
-      if (ret < 0)
-        {
-          /* This should only happen if the wait was canceled by an signal */
+      ret = nxsem_wait(&priv->devsem);
 
-          DEBUGASSERT(errno == EINTR);
-        }
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
-  while (ret != OK);
+  while (ret == -EINTR);
 
   /* Stop the event loop (Hmm.. the caller must be sure that there are no
    * open references to the touchscreen driver.  This might better be
diff --git a/arch/sim/src/up_uartwait.c b/arch/sim/src/up_uartwait.c
index b3f6ecd359..cf1e31cf72 100644
--- a/arch/sim/src/up_uartwait.c
+++ b/arch/sim/src/up_uartwait.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/sim/src/up_uartwait.c
  *
- *   Copyright (C) 20014Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -84,5 +84,5 @@ void simuart_wait(void)
 {
   /* Should only fail if interrupted by a signal */
 
-  while (sem_wait(&g_uartavail) < 0);
+  while (nxsem_wait(&g_uartavail) < 0);
 }
diff --git a/arch/z16/src/z16f/z16f_espi.c b/arch/z16/src/z16f/z16f_espi.c
index 97964daf60..da5b88611e 100644
--- a/arch/z16/src/z16f/z16f_espi.c
+++ b/arch/z16/src/z16f/z16f_espi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/z16/src/z16f/z16f_espi.c
  *
- *   Copyright (C) 2014, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014, 2016-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -368,27 +368,32 @@ static void spi_flush(FAR struct z16f_spi_s *priv)
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct z16f_spi_s *priv = (FAR struct z16f_spi_s *)dev;
+  int ret;
 
   spiinfo("lock=%d\n", lock);
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/z80/src/ez80/ez80_i2c.c b/arch/z80/src/ez80/ez80_i2c.c
index 898d103e48..6413a39d4b 100644
--- a/arch/z80/src/ez80/ez80_i2c.c
+++ b/arch/z80/src/ez80/ez80_i2c.c
@@ -1,7 +1,8 @@
 /****************************************************************************
  * arch/z80/src/ez80/ez80_i2c.c
  *
- *   Copyright(C) 2009, 2011, 2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright(C) 2009, 2011, 2013, 2016-2017 Gregory Nutt. All rights
+ *     reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -139,16 +140,21 @@ const struct i2c_ops_s g_ops =
 
 static void ez80_i2c_semtake(void)
 {
-  /* Take the I2C semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&g_i2csem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if
-       * the wait was awakened by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&g_i2csem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 #define ez80_i2c_semgive() nxsem_post(&g_i2csem)
diff --git a/arch/z80/src/ez80/ez80_spi.c b/arch/z80/src/ez80/ez80_spi.c
index a5ed1b074e..d7f14c7e01 100644
--- a/arch/z80/src/ez80/ez80_spi.c
+++ b/arch/z80/src/ez80/ez80_spi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/z80/src/ez80/ez80_spi.c
  *
- *   Copyright (C) 2009-2010, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2009-2010, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -141,25 +141,31 @@ static sem_t g_exclsem = SEM_INITIALIZER(1);  /* For mutually exclusive access *
 
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
+  int ret;
+
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&g_exclsem) != 0)
+      do
         {
+          ret = nxsem_wait(&g_exclsem);
+
           /* The only case that an error should occur here is if the wait
            * was awakened by a signal.
            */
 
-          DEBUGASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&g_exclsem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
diff --git a/arch/z80/src/z8/z8_i2c.c b/arch/z80/src/z8/z8_i2c.c
index 6cda77aa97..465debc403 100644
--- a/arch/z80/src/z8/z8_i2c.c
+++ b/arch/z80/src/z8/z8_i2c.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/z80/src/z8/z8_i2c.c
  *
- *   Copyright(C) 2009, 2011, 2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright(C) 2009, 2011, 2013, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -140,16 +140,21 @@ const struct i2c_ops_s g_ops =
 
 static void z8_i2c_semtake(void)
 {
-  /* Take the I2C semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&g_i2csem) != 0)
+  do
     {
-      /* The only case that an error should occr here is if
-       * the wait was awakened by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&g_i2csem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 #define z8_i2c_semgive() nxsem_post(&g_i2csem)
diff --git a/audio/audio.c b/audio/audio.c
index ee6b5f057f..1acf6fb182 100644
--- a/audio/audio.c
+++ b/audio/audio.c
@@ -150,7 +150,7 @@ static int audio_open(FAR struct file *filep)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&upper->exclsem);
+  ret = nxsem_wait(&upper->exclsem);
   if (ret < 0)
     {
       ret = -errno;
@@ -202,7 +202,7 @@ static int audio_close(FAR struct file *filep)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&upper->exclsem);
+  ret = nxsem_wait(&upper->exclsem);
   if (ret < 0)
     {
       ret = -errno;
@@ -362,7 +362,7 @@ static int audio_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&upper->exclsem);
+  ret = nxsem_wait(&upper->exclsem);
   if (ret < 0)
     {
       return ret;
diff --git a/binfmt/pcode.c b/binfmt/pcode.c
index aaf92932bc..17b1383bbe 100644
--- a/binfmt/pcode.c
+++ b/binfmt/pcode.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * binfmt/pcode.c
  *
- *   Copyright (C) 2014-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -459,10 +459,10 @@ static int pcode_load(struct binary_s *binp)
 
   do
     {
-      ret = sem_wait(&g_pcode_handoff.exclsem);
-      DEBUGASSERT(ret == OK || get_errno() == EINTR);
+      ret = nxsem_wait(&g_pcode_handoff.exclsem);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 
   /* Save the data that we need to handoff to the child thread */
 
diff --git a/configs/mcu123-lpc214x/src/lpc2148_spi1.c b/configs/mcu123-lpc214x/src/lpc2148_spi1.c
index 1629d95697..a5001a5a0c 100644
--- a/configs/mcu123-lpc214x/src/lpc2148_spi1.c
+++ b/configs/mcu123-lpc214x/src/lpc2148_spi1.c
@@ -1,7 +1,8 @@
 /****************************************************************************
  * config/mcu123-lpc214x/src/lpc2148_spi1.c
  *
- *   Copyright (C) 2008-2010, 2012, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2008-2010, 2012, 2016-2016 Gregory Nutt. All rights
+ *     reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -171,25 +172,31 @@ static sem_t g_exclsem = SEM_INITIALIZER(1);  /* For mutually exclusive access *
 
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
+  int ret;
+
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&g_exclsem) != 0)
+      do
         {
+          ret = nxsem_wait(&g_exclsem);
+
           /* The only case that an error should occur here is if the wait
            * was awakened by a signal.
            */
 
-          DEBUGASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&g_exclsem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
diff --git a/configs/mikroe-stm32f4/src/stm32_touchscreen.c b/configs/mikroe-stm32f4/src/stm32_touchscreen.c
index 9050810b29..8dfb259f48 100644
--- a/configs/mikroe-stm32f4/src/stm32_touchscreen.c
+++ b/configs/mikroe-stm32f4/src/stm32_touchscreen.c
@@ -1,7 +1,7 @@
 /************************************************************************************
  * configs/mikroe-stm32f4/src/stm32_touchscreen.c
  *
- *   Copyright (C) 2012-2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012-2013, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  *   Modified:  May, 2013 by Ken Pettit to adapt for Mikroe-STM32M4 board
@@ -709,7 +709,7 @@ static int tc_waitsample(FAR struct tc_dev_s *priv,
       /* Wait for a change in the touchscreen state */
 
       priv->nwaiters++;
-      ret = sem_wait(&priv->waitsem);
+      ret = nxsem_wait(&priv->waitsem);
       priv->nwaiters--;
 
       if (ret < 0)
@@ -718,8 +718,7 @@ static int tc_waitsample(FAR struct tc_dev_s *priv,
            * the failure now.
            */
 
-          DEBUGASSERT(errno == EINTR);
-          ret = -EINTR;
+          DEBUGASSERT(ret == -EINTR);
           goto errout;
         }
     }
@@ -729,7 +728,7 @@ static int tc_waitsample(FAR struct tc_dev_s *priv,
    * Interrupts and pre-emption will be re-enabled while we wait.
    */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
 
 errout:
   /* Restore pre-emption.  We might get suspended here but that is okay
@@ -1127,13 +1126,13 @@ static int tc_open(FAR struct file *filep)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Increment the reference count */
@@ -1182,13 +1181,13 @@ static int tc_close(FAR struct file *filep)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Decrement the reference count unless it would decrement a negative
@@ -1239,13 +1238,13 @@ static ssize_t tc_read(FAR struct file *filep, FAR char *buffer, size_t len)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Try to read sample data. */
@@ -1351,13 +1350,13 @@ static int tc_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Process the IOCTL by command */
@@ -1398,13 +1397,13 @@ static int tc_poll(FAR struct file *filep, FAR struct pollfd *fds,
 
   /* Are we setting up the poll?  Or tearing it down? */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   if (setup)
diff --git a/configs/olimex-strp711/src/str71_spi.c b/configs/olimex-strp711/src/str71_spi.c
index 2e3f5f2642..1c18a4e553 100644
--- a/configs/olimex-strp711/src/str71_spi.c
+++ b/configs/olimex-strp711/src/str71_spi.c
@@ -1,7 +1,8 @@
 /****************************************************************************
  * config/olimex-strp711/src/str71_spi.c
  *
- *   Copyright (C) 2008-2010, 2012, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2008-2010, 2012, 2016-2017 Gregory Nutt. All rights
+ *     reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -568,26 +569,31 @@ static inline void spi_drain(FAR struct str71x_spidev_s *priv)
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct str71x_spidev_s *priv = (FAR struct str71x_spidev_s *)dev;
+  int ret;
 
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
+          ret = nxsem_wait(&priv->exclsem);
+
           /* The only case that an error should occur here is if the wait
            * was awakened by a signal.
            */
 
-          DEBUGASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
diff --git a/configs/pic32mx7mmb/src/pic32_touchscreen.c b/configs/pic32mx7mmb/src/pic32_touchscreen.c
index d8c0770a89..950d1fc867 100644
--- a/configs/pic32mx7mmb/src/pic32_touchscreen.c
+++ b/configs/pic32mx7mmb/src/pic32_touchscreen.c
@@ -1,7 +1,7 @@
 /************************************************************************************
  * configs/pic32mx7mmb/src/pic32_touchscreen.c
  *
- *   Copyright (C) 2012 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -595,7 +595,7 @@ static int tc_waitsample(FAR struct tc_dev_s *priv,
       /* Wait for a change in the touchscreen state */
 
       priv->nwaiters++;
-      ret = sem_wait(&priv->waitsem);
+      ret = nxsem_wait(&priv->waitsem);
       priv->nwaiters--;
 
       if (ret < 0)
@@ -604,8 +604,7 @@ static int tc_waitsample(FAR struct tc_dev_s *priv,
            * the failure now.
            */
 
-          DEBUGASSERT(errno == EINTR);
-          ret = -EINTR;
+          DEBUGASSERT(ret == -EINTR);
           goto errout;
         }
     }
@@ -615,7 +614,7 @@ static int tc_waitsample(FAR struct tc_dev_s *priv,
    * Interrupts and pre-emption will be re-enabled while we wait.
    */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
 
 errout:
   /* Restore pre-emption.  We might get suspended here but that is okay
@@ -996,13 +995,13 @@ static int tc_open(FAR struct file *filep)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Increment the reference count */
@@ -1051,13 +1050,13 @@ static int tc_close(FAR struct file *filep)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Decrement the reference count unless it would decrement a negative
@@ -1108,13 +1107,13 @@ static ssize_t tc_read(FAR struct file *filep, FAR char *buffer, size_t len)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Try to read sample data. */
@@ -1220,13 +1219,13 @@ static int tc_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Process the IOCTL by command */
@@ -1267,13 +1266,13 @@ static int tc_poll(FAR struct file *filep, FAR struct pollfd *fds,
 
   /* Are we setting up the poll?  Or tearing it down? */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   if (setup)
diff --git a/configs/samv71-xult/src/sam_ili9488.c b/configs/samv71-xult/src/sam_ili9488.c
index 5d6c161558..a0e8ac9c06 100644
--- a/configs/samv71-xult/src/sam_ili9488.c
+++ b/configs/samv71-xult/src/sam_ili9488.c
@@ -983,11 +983,11 @@ static int sam_lcd_dmawait(FAR struct sam_dev_s *priv, uint32_t timeout)
        * incremented and there will be no wait.
        */
 
-      ret = sem_wait(&priv->waitsem);
+      ret = nxsem_wait(&priv->waitsem);
 
       /* The only expected failure is EINTR */
 
-      DEBUGASSERT(ret == OK || errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
 
   /* Dump the collect DMA sample data */
diff --git a/configs/stm32butterfly2/src/stm32_mmcsd.c b/configs/stm32butterfly2/src/stm32_mmcsd.c
index 68749f0dc2..fb425b1dc4 100644
--- a/configs/stm32butterfly2/src/stm32_mmcsd.c
+++ b/configs/stm32butterfly2/src/stm32_mmcsd.c
@@ -100,7 +100,7 @@ static void *stm32_cd_thread(void *arg)
   spiinfo("INFO: Runnig card detect thread\n");
   while (1)
     {
-      sem_wait(&g_cdsem);
+      nxsem_wait(&g_cdsem);
       spiinfo("INFO: Card has been inserted, initializing\n");
 
       if (g_chmediaclbk)
diff --git a/configs/zp214xpa/src/lpc2148_spi1.c b/configs/zp214xpa/src/lpc2148_spi1.c
index 75a8cdf19c..a7b479082b 100644
--- a/configs/zp214xpa/src/lpc2148_spi1.c
+++ b/configs/zp214xpa/src/lpc2148_spi1.c
@@ -1,7 +1,8 @@
 /****************************************************************************
  * config/zp214xpa/src/lpc2148_spi1.c
  *
- *   Copyright (C) 2008-2010, 2012, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2008-2010, 2012, 2016-2017 Gregory Nutt. All rights
+ *     reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -174,25 +175,31 @@ static sem_t g_exclsem = SEM_INITIALIZER(1);  /* For mutually exclusive access *
 
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
+  int ret;
+
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&g_exclsem) != 0)
+      do
         {
+          ret = nxsem_wait(&g_exclsem);
+
           /* The only case that an error should occur here is if the wait
            * was awakened by a signal.
            */
 
-          DEBUGASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&g_exclsem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
diff --git a/crypto/random_pool.c b/crypto/random_pool.c
index 1619f33cbe..830743eed7 100644
--- a/crypto/random_pool.c
+++ b/crypto/random_pool.c
@@ -499,10 +499,21 @@ void up_rngaddentropy(enum rnd_source_t kindof, FAR const uint32_t *buf,
 
 void up_rngreseed(void)
 {
-  while (sem_wait(&g_rng.rd_sem) != 0)
+  int ret;
+
+  do
     {
-      assert(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&g_rng.rd_sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   if (g_rng.rd_newentr >= MIN_SEED_NEW_ENTROPY_WORDS)
     {
@@ -551,10 +562,21 @@ void up_randompool_initialize(void)
 
 void getrandom(FAR void *bytes, size_t nbytes)
 {
-  while (sem_wait(&g_rng.rd_sem) != 0)
+  int ret;
+
+  do
     {
-      assert(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&g_rng.rd_sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   rng_buf_internal(bytes, nbytes);
   nxsem_post(&g_rng.rd_sem);
diff --git a/drivers/analog/adc.c b/drivers/analog/adc.c
index a33ca8cf81..a54be24301 100644
--- a/drivers/analog/adc.c
+++ b/drivers/analog/adc.c
@@ -121,15 +121,12 @@ static int adc_open(FAR struct file *filep)
   FAR struct inode     *inode = filep->f_inode;
   FAR struct adc_dev_s *dev   = inode->i_private;
   uint8_t               tmp;
-  int                   ret   = OK;
+  int                   ret;
 
   /* If the port is the middle of closing, wait until the close is finished */
 
-  if (sem_wait(&dev->ad_closesem) != OK)
-    {
-      ret = -errno;
-    }
-  else
+  ret = nxsem_wait(&dev->ad_closesem);
+  if (ret >= 0)
     {
       /* Increment the count of references to the device.  If this the first
        * time that the driver has been opened for this device, then initialize
@@ -193,13 +190,10 @@ static int adc_close(FAR struct file *filep)
   FAR struct inode     *inode = filep->f_inode;
   FAR struct adc_dev_s *dev   = inode->i_private;
   irqstate_t            flags;
-  int                   ret = OK;
+  int                   ret;
 
-  if (sem_wait(&dev->ad_closesem) != OK)
-    {
-      ret = -errno;
-    }
-  else
+  ret = nxsem_wait(&dev->ad_closesem);
+  if (ret >= 0)
     {
       /* Decrement the references to the driver.  If the reference count will
        * decrement to 0, then uninitialize the driver.
@@ -295,11 +289,10 @@ static ssize_t adc_read(FAR struct file *filep, FAR char *buffer, size_t buflen)
           /* Wait for a message to be received */
 
           dev->ad_nrxwaiters++;
-          ret = sem_wait(&dev->ad_recv.af_sem);
+          ret = nxsem_wait(&dev->ad_recv.af_sem);
           dev->ad_nrxwaiters--;
           if (ret < 0)
             {
-              ret = -errno;
               goto return_with_irqdisabled;
             }
         }
diff --git a/drivers/analog/comp.c b/drivers/analog/comp.c
index 49925b1ff9..cceaf4ee41 100644
--- a/drivers/analog/comp.c
+++ b/drivers/analog/comp.c
@@ -152,14 +152,21 @@ static void comp_pollnotify(FAR struct comp_dev_s *dev,
 #ifndef CONFIG_DISABLE_POLL
 static void comp_semtake(FAR sem_t *sem)
 {
-  while (sem_wait(sem) != 0)
+ int ret;
+
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(get_errno() == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 #endif
 
@@ -270,15 +277,12 @@ static int comp_open(FAR struct file *filep)
   FAR struct inode      *inode = filep->f_inode;
   FAR struct comp_dev_s *dev   = inode->i_private;
   uint8_t                tmp;
-  int                    ret   = OK;
+  int                    ret;
 
   /* If the port is the middle of closing, wait until the close is finished */
 
-  if (sem_wait(&dev->ad_sem) != OK)
-    {
-      ret = -errno;
-    }
-  else
+  ret = nxsem_wait(&dev->ad_sem);
+  if (ret >= 0)
     {
       /* Increment the count of references to the device.  If this the first
        * time that the driver has been opened for this device, then initialize
@@ -333,13 +337,10 @@ static int comp_close(FAR struct file *filep)
   FAR struct inode     *inode = filep->f_inode;
   FAR struct comp_dev_s *dev   = inode->i_private;
   irqstate_t            flags;
-  int                   ret = OK;
+  int                   ret;
 
-  if (sem_wait(&dev->ad_sem) != OK)
-    {
-      ret = -errno;
-    }
-  else
+  ret = nxsem_wait(&dev->ad_sem);
+  if (ret >= 0)
     {
       /* Decrement the references to the driver.  If the reference count will
        * decrement to 0, then uninitialize the driver.
@@ -391,11 +392,11 @@ static ssize_t comp_read(FAR struct file *filep, FAR char *buffer, size_t buflen
     }
 
 #ifndef CONFIG_DISABLE_POLL
-  ret = sem_wait(&dev->ad_readsem);
+  ret = nxsem_wait(&dev->ad_readsem);
   if (ret < 0)
     {
-      aerr("sem_wait() failed: %d\n", errno);
-      return -errno;
+      aerr("nxsem_wait() failed: %d\n", ret);
+      return ret;
     }
 
   buffer[0] = dev->val;
diff --git a/drivers/analog/dac.c b/drivers/analog/dac.c
index 90d138641b..af57f5a3c7 100644
--- a/drivers/analog/dac.c
+++ b/drivers/analog/dac.c
@@ -7,7 +7,7 @@
  *
  * Derived from drivers/can.c
  *
- *   Copyright (C) 2008-2009Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2008-2009, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -114,15 +114,12 @@ static int dac_open(FAR struct file *filep)
   FAR struct inode     *inode = filep->f_inode;
   FAR struct dac_dev_s *dev   = inode->i_private;
   uint8_t               tmp;
-  int                   ret   = OK;
+  int                   ret;
 
   /* If the port is the middle of closing, wait until the close is finished */
 
-  if (sem_wait(&dev->ad_closesem) != OK)
-    {
-      ret = -errno;
-    }
-  else
+  ret = nxsem_wait(&dev->ad_closesem);
+  if (ret >= 0)
     {
       /* Increment the count of references to the device.  If this the first
        * time that the driver has been opened for this device, then initialize
@@ -182,13 +179,10 @@ static int dac_close(FAR struct file *filep)
   FAR struct inode     *inode = filep->f_inode;
   FAR struct dac_dev_s *dev   = inode->i_private;
   irqstate_t            flags;
-  int                   ret = OK;
+  int                   ret;
 
-  if (sem_wait(&dev->ad_closesem) != OK)
-    {
-      ret = -errno;
-    }
-  else
+  ret = nxsem_wait(&dev->ad_closesem);
+  if (ret >= 0)
     {
       /* Decrement the references to the driver.  If the reference count will
        * decrement to 0, then uninitialize the driver.
@@ -372,10 +366,9 @@ static ssize_t dac_write(FAR struct file *filep, FAR const char *buffer, size_t
 
           do
             {
-              ret = sem_wait(&fifo->af_sem);
-              if (ret < 0 && errno != EINTR)
+              ret = nxsem_wait(&fifo->af_sem);
+              if (ret < 0 && ret != -EINTR)
                 {
-                  ret = -errno;
                   goto return_with_irqdisabled;
                 }
             }
diff --git a/drivers/analog/ltc1867l.c b/drivers/analog/ltc1867l.c
index 6b2d8e0a65..526978222b 100644
--- a/drivers/analog/ltc1867l.c
+++ b/drivers/analog/ltc1867l.c
@@ -239,7 +239,7 @@ static int adc_ioctl(FAR struct adc_dev_s *dev, int cmd, unsigned long arg)
 
   if (cmd == ANIOC_TRIGGER)
     {
-      while (sem_wait(&priv->sem) != OK);
+      while (nxsem_wait(&priv->sem) < 0);
 
       adc_lock(spi);
 
diff --git a/drivers/analog/opamp.c b/drivers/analog/opamp.c
index 76af03bacc..50e43d52c9 100644
--- a/drivers/analog/opamp.c
+++ b/drivers/analog/opamp.c
@@ -98,15 +98,12 @@ static int opamp_open(FAR struct file *filep)
   FAR struct inode      *inode = filep->f_inode;
   FAR struct opamp_dev_s *dev   = inode->i_private;
   uint8_t                tmp;
-  int                    ret   = OK;
+  int                    ret;
 
   /* If the port is the middle of closing, wait until the close is finished */
 
-  if (sem_wait(&dev->ad_closesem) != OK)
-    {
-      ret = -errno;
-    }
-  else
+  ret = nxsem_wait(&dev->ad_closesem);
+  if (ret >= 0)
     {
       /* Increment the count of references to the device.  If this the first
        * time that the driver has been opened for this device, then initialize
@@ -161,13 +158,10 @@ static int opamp_close(FAR struct file *filep)
   FAR struct inode     *inode = filep->f_inode;
   FAR struct opamp_dev_s *dev   = inode->i_private;
   irqstate_t            flags;
-  int                   ret = OK;
+  int                   ret;
 
-  if (sem_wait(&dev->ad_closesem) != OK)
-    {
-      ret = -errno;
-    }
-  else
+  ret = nxsem_wait(&dev->ad_closesem);
+  if (ret >= 0)
     {
       /* Decrement the references to the driver.  If the reference count will
        * decrement to 0, then uninitialize the driver.
diff --git a/drivers/audio/cs43l22.c b/drivers/audio/cs43l22.c
index aaf58a1514..8dabd1cc31 100644
--- a/drivers/audio/cs43l22.c
+++ b/drivers/audio/cs43l22.c
@@ -369,10 +369,10 @@ static void cs43l22_takesem(sem_t * sem)
 
   do
     {
-      ret = sem_wait(sem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(sem);
+      DEBUGASSERT(ret == 0 || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /************************************************************************************
diff --git a/drivers/audio/i2schar.c b/drivers/audio/i2schar.c
index 65e061e4db..7b412d6da1 100644
--- a/drivers/audio/i2schar.c
+++ b/drivers/audio/i2schar.c
@@ -6,7 +6,7 @@
  * audio driver.  It is not suitable for use in any real driver application
  * in its current form.
  *
- *   Copyright (C) 2013 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -241,12 +241,10 @@ static ssize_t i2schar_read(FAR struct file *filep, FAR char *buffer,
 
   /* Get exclusive access to i2c character driver */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      ret = -errno;
-      DEBUGASSERT(ret < 0);
-      i2serr("ERROR: sem_wait returned: %d\n", ret);
+      i2serr("ERROR: nxsem_wait returned: %d\n", ret);
       goto errout_with_reference;
     }
 
@@ -316,12 +314,10 @@ static ssize_t i2schar_write(FAR struct file *filep, FAR const char *buffer,
 
   /* Get exclusive access to i2c character driver */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      ret = -errno;
-      DEBUGASSERT(ret < 0);
-      i2serr("ERROR: sem_wait returned: %d\n", ret);
+      i2serr("ERROR: nxsem_wait returned: %d\n", ret);
       goto errout_with_reference;
     }
 
diff --git a/drivers/audio/tone.c b/drivers/audio/tone.c
index a5adeeed48..bc5e5740c1 100644
--- a/drivers/audio/tone.c
+++ b/drivers/audio/tone.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/audio/tone.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Alan Carvalho de Assis <acassis@gmail.com>
  *
  * This driver is based on Tone Alarm driver from PX4 project. It was
@@ -778,10 +778,9 @@ static int tone_open(FAR struct file *filep)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&upper->exclsem);
+  ret = nxsem_wait(&upper->exclsem);
   if (ret < 0)
     {
-      ret = -get_errno();
       goto errout;
     }
 
@@ -828,10 +827,9 @@ static int tone_close(FAR struct file *filep)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&upper->exclsem);
+  ret = nxsem_wait(&upper->exclsem);
   if (ret < 0)
     {
-      ret = -get_errno();
       goto errout;
     }
 
diff --git a/drivers/audio/vs1053.c b/drivers/audio/vs1053.c
index 5861d080c4..d0387a10fa 100644
--- a/drivers/audio/vs1053.c
+++ b/drivers/audio/vs1053.c
@@ -1159,7 +1159,7 @@ static void vs1053_feeddata(FAR struct vs1053_struct_s *dev)
 
               /* Lock the buffer queue to pop the next buffer */
 
-              if ((ret = sem_wait(&dev->apbq_sem)) != OK)
+              if ((ret = nxsem_wait(&dev->apbq_sem)) < 0)
                 {
 #ifdef CONFIG_AUDIO_MULTI_SESSION
                   dev->lower.upper(dev->lower.priv,
@@ -1193,6 +1193,7 @@ static void vs1053_feeddata(FAR struct vs1053_struct_s *dev)
     }
 
   /* Deselect the SPI bus and unlock it */
+
 err_out:
   SPI_SELECT(spi, SPIDEV_AUDIO_DATA(0), false);
   vs1053_spi_unlock(spi);
@@ -1349,7 +1350,7 @@ static void *vs1053_workerthread(pthread_addr_t pvarg)
 
   /* Cancel any leftover buffer in our queue */
 
-  if (sem_wait(&dev->apbq_sem) == OK)
+  if (nxsem_wait(&dev->apbq_sem) == OK)
     {
       /* Get the next buffer from the queue */
 
@@ -1445,7 +1446,7 @@ static int vs1053_start(FAR struct audio_lowerhalf_s *lower)
 
   /* Pop the first enqueued buffer */
 
-  if ((ret = sem_wait(&dev->apbq_sem)) == OK)
+  if ((ret = nxsem_wait(&dev->apbq_sem)) == OK)
     {
       dev->apb = (FAR struct ap_buffer_s *) dq_remfirst(&dev->apbq);
       apb_reference(dev->apb);               /* Add our buffer reference */
@@ -1610,7 +1611,7 @@ static int vs1053_enqueuebuffer(FAR struct audio_lowerhalf_s *lower,
 
   /* Lock access to the apbq */
 
-  if ((ret = sem_wait(&dev->apbq_sem)) == OK)
+  if ((ret = nxsem_wait(&dev->apbq_sem)) == OK)
     {
       /* We can now safely add the buffer to the queue */
 
@@ -1705,13 +1706,14 @@ static int vs1053_reserve(FAR struct audio_lowerhalf_s *lower)
 #endif
 {
   FAR struct vs1053_struct_s *dev = (struct vs1053_struct_s *) lower;
-  int   ret = OK;
+  int   ret;
 
   /* Borrow the APBQ semaphore for thread sync */
 
-  if (sem_wait(&dev->apbq_sem) != OK)
+  ret = nxsem_wait(&dev->apbq_sem);
+  if (ret < 0)
     {
-      return -EBUSY;
+      return ret;
     }
 
   if (dev->busy)
@@ -1751,6 +1753,7 @@ static int vs1053_release(FAR struct audio_lowerhalf_s *lower)
 {
   FAR struct vs1053_struct_s *dev = (struct vs1053_struct_s *) lower;
   void  *value;
+  int ret;
 
   /* Join any old worker thread we had created to prevent a memory leak */
 
@@ -1762,9 +1765,10 @@ static int vs1053_release(FAR struct audio_lowerhalf_s *lower)
 
   /* Borrow the APBQ semaphore for thread sync */
 
-  if (sem_wait(&dev->apbq_sem) != OK)
+  ret = nxsem_wait(&dev->apbq_sem);
+  if (ret < 0)
     {
-      return -EBUSY;
+      return ret;
     }
 
   /* Really we should free any queued buffers here */
diff --git a/drivers/audio/wm8904.c b/drivers/audio/wm8904.c
index 11141b17e0..8040373119 100644
--- a/drivers/audio/wm8904.c
+++ b/drivers/audio/wm8904.c
@@ -418,10 +418,10 @@ static void wm8904_takesem(sem_t *sem)
 
   do
     {
-      ret = sem_wait(sem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(sem);
+      DEBUGASSERT(ret == 0 || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /************************************************************************************
diff --git a/drivers/bch/bchlib_sem.c b/drivers/bch/bchlib_sem.c
index ff221d934f..b2b78bfcb5 100644
--- a/drivers/bch/bchlib_sem.c
+++ b/drivers/bch/bchlib_sem.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/bch/bchlib_sem.c
  *
- *   Copyright (C) 2008-2009 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2008-2009, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -43,24 +43,10 @@
 #include <assert.h>
 #include <debug.h>
 
+#include <nuttx/semaphore.h>
+
 #include "bch.h"
 
-/****************************************************************************
- * Pre-processor Definitions
- ****************************************************************************/
-
-/****************************************************************************
- * Private Function Prototypes
- ****************************************************************************/
-
-/****************************************************************************
- * Private Data
- ****************************************************************************/
-
-/****************************************************************************
- * Private Functions
- ****************************************************************************/
-
 /****************************************************************************
  * Public Functions
  ****************************************************************************/
@@ -71,14 +57,19 @@
 
 void bchlib_semtake(FAR struct bchlib_s *bch)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&bch->sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if
-       * the wait was awakened by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&bch->sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
diff --git a/drivers/can/can.c b/drivers/can/can.c
index eddc505b90..bfde490de4 100644
--- a/drivers/can/can.c
+++ b/drivers/can/can.c
@@ -1,7 +1,8 @@
 /****************************************************************************
  * drivers/can/can.c
  *
- *   Copyright (C) 2008-2009, 2011-2012, 2014-2015 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2008-2009, 2011-2012, 2014-2015, 2017 Gregory Nutt. All
+ *     rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  *   Copyright (C) 2016 Omni Hoverboards Inc. All rights reserved.
@@ -179,22 +180,18 @@ static const struct file_operations g_canops =
 
 static int can_takesem(FAR sem_t *sem)
 {
-  int errcode;
+  int ret;
 
   /* Take a count from the semaphore, possibly waiting */
 
-  if (sem_wait(sem) < 0)
-    {
-      /* The only case that an error should occur here is if the wait
-       * was awakened by a signal
-       */
+  ret = nxsem_wait(sem);
 
-      errcode = get_errno();
-      DEBUGASSERT(errcode == EINTR);
-      return -errcode;
-    }
+  /* The only case that an error should occur here is if the wait
+   * was awakened by a signal
+   */
 
-  return OK;
+  DEBUGASSERT(ret == OK || ret == -EINTR);
+  return ret;
 }
 
 /****************************************************************************
diff --git a/drivers/can/mcp2515.c b/drivers/can/mcp2515.c
index d181d44f24..a7c9ac9163 100644
--- a/drivers/can/mcp2515.c
+++ b/drivers/can/mcp2515.c
@@ -499,10 +499,10 @@ static void mcp2515_dev_lock(FAR struct mcp2515_can_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->locksem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(&priv->locksem);
+      DEBUGASSERT(ret == 0 || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/drivers/dev_null.c b/drivers/dev_null.c
index 516beb8788..af882d49b6 100644
--- a/drivers/dev_null.c
+++ b/drivers/dev_null.c
@@ -45,6 +45,7 @@
 #include <poll.h>
 #include <errno.h>
 
+#include <nuttx/semaphore.h>
 #include <nuttx/fs/fs.h>
 #include <nuttx/drivers/drivers.h>
 
diff --git a/drivers/dev_zero.c b/drivers/dev_zero.c
index 5e3ac63311..5f836bb58e 100644
--- a/drivers/dev_zero.c
+++ b/drivers/dev_zero.c
@@ -45,6 +45,7 @@
 #include <poll.h>
 #include <errno.h>
 
+#include <nuttx/semaphore.h>
 #include <nuttx/fs/fs.h>
 #include <nuttx/drivers/drivers.h>
 
diff --git a/drivers/eeprom/spi_xx25xx.c b/drivers/eeprom/spi_xx25xx.c
index e7fc3e1535..f2efa86ebf 100644
--- a/drivers/eeprom/spi_xx25xx.c
+++ b/drivers/eeprom/spi_xx25xx.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/eeprom/spi_xx25xx.c
  *
- *   Copyright (C) 2014 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014, 2017 Gregory Nutt. All rights reserved.
  *   Author: Sebastien Lorquet <sebastien@lorquet.fr>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -440,16 +440,21 @@ static void ee25xx_writepage(FAR struct ee25xx_dev_s *eedev, uint32_t devaddr,
 
 static void ee25xx_semtake(FAR struct ee25xx_dev_s *eedev)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&eedev->sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if
-       * the wait was awakened by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&eedev->sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/drivers/i2c/i2c_driver.c b/drivers/i2c/i2c_driver.c
index a258428485..ae724553ae 100644
--- a/drivers/i2c/i2c_driver.c
+++ b/drivers/i2c/i2c_driver.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/i2c/i2c_driver.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -146,12 +146,10 @@ static int i2cdrvr_open(FAR struct file *filep)
 
   /* Get exclusive access to the I2C driver state structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      int errcode = errno;
-      DEBUGASSERT(errcode < 0);
-      return -errcode;
+      return ret;
     }
 
   /* Increment the count of open references on the RTC driver */
@@ -185,12 +183,10 @@ static int i2cdrvr_close(FAR struct file *filep)
 
   /* Get exclusive access to the I2C driver state structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      int errcode = errno;
-      DEBUGASSERT(errcode < 0);
-      return -errcode;
+      return ret;
     }
 
   /* Decrement the count of open references on the RTC driver */
@@ -258,12 +254,10 @@ static int i2cdrvr_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 #ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
   /* Get exclusive access to the I2C driver state structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      int errcode = errno;
-      DEBUGASSERT(errcode < 0);
-      return -errcode;
+      return ret;
     }
 #endif
 
@@ -333,12 +327,10 @@ static int i2cdrvr_unlink(FAR struct inode *inode)
 
   /* Get exclusive access to the I2C driver state structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      int errcode = errno;
-      DEBUGASSERT(errcode < 0);
-      return -errcode;
+      return ret;
     }
 
   /* Are there open references to the driver data structure? */
diff --git a/drivers/input/ads7843e.c b/drivers/input/ads7843e.c
index 6dff56474c..195aaa0260 100644
--- a/drivers/input/ads7843e.c
+++ b/drivers/input/ads7843e.c
@@ -1,7 +1,8 @@
 /****************************************************************************
  * drivers/input/ads7843e.c
  *
- *   Copyright (C) 2011-2012, 2014, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011-2012, 2014, 2016-2017 Gregory Nutt. All rights
+ *     reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *            Diego Sanchez <dsanchez@nx-engineering.com>
  *
@@ -420,7 +421,7 @@ static int ads7843e_waitsample(FAR struct ads7843e_dev_s *priv,
 
       iinfo("Waiting..\n");
       priv->nwaiters++;
-      ret = sem_wait(&priv->waitsem);
+      ret = nxsem_wait(&priv->waitsem);
       priv->nwaiters--;
 
       if (ret < 0)
@@ -429,9 +430,7 @@ static int ads7843e_waitsample(FAR struct ads7843e_dev_s *priv,
            * the failure now.
            */
 
-          ierr("ERROR: sem_wait: %d\n", errno);
-          DEBUGASSERT(errno == EINTR);
-          ret = -EINTR;
+          ierr("ERROR: nxsem_wait: %d\n", ret);
           goto errout;
         }
     }
@@ -443,7 +442,7 @@ static int ads7843e_waitsample(FAR struct ads7843e_dev_s *priv,
    * Interrupts and pre-emption will be re-enabled while we wait.
    */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
 
 errout:
   /* Then re-enable interrupts.  We might get interrupt here and there
@@ -554,15 +553,15 @@ static void ads7843e_worker(FAR void *arg)
 
   do
     {
-      ret = sem_wait(&priv->devsem);
+      ret = nxsem_wait(&priv->devsem);
 
       /* This should only fail if the wait was canceled by an signal
        * (and the worker thread will receive a lot of signals).
        */
 
-      DEBUGASSERT(ret == OK || errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 
   /* Check for pen up or down by reading the PENIRQ GPIO. */
 
@@ -763,13 +762,13 @@ static int ads7843e_open(FAR struct file *filep)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was cancelled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Increment the reference count */
@@ -820,13 +819,13 @@ static int ads7843e_close(FAR struct file *filep)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Decrement the reference count unless it would decrement a negative
@@ -880,14 +879,14 @@ static ssize_t ads7843e_read(FAR struct file *filep, FAR char *buffer, size_t le
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was cancelled by an signal */
 
-      ierr("ERROR: sem_wait: %d\n", errno);
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      ierr("ERROR: nxsem_wait: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Try to read sample data. */
@@ -993,13 +992,13 @@ static int ads7843e_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was cancelled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Process the IOCTL by command */
@@ -1053,13 +1052,13 @@ static int ads7843e_poll(FAR struct file *filep, FAR struct pollfd *fds,
 
   /* Are we setting up the poll?  Or tearing it down? */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was cancelled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   if (setup)
diff --git a/drivers/input/ajoystick.c b/drivers/input/ajoystick.c
index f2e8f89d80..33124143ea 100644
--- a/drivers/input/ajoystick.c
+++ b/drivers/input/ajoystick.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/ajoystick.c
  *
- *   Copyright (C) 2014 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -180,18 +180,18 @@ static const struct file_operations ajoy_fops =
 
 static inline int ajoy_takesem(sem_t *sem)
 {
+  int ret;
+
   /* Take a count from the semaphore, possibly waiting */
 
-  if (sem_wait(sem) < 0)
-    {
-      /* EINTR is the only error that we expect */
+  ret = nxsem_wait(sem);
 
-      int errcode = get_errno();
-      DEBUGASSERT(errcode == EINTR);
-      return -errcode;
-    }
+  /* The only case that an error should occur here is if the wait
+   * was awakened by a signal
+   */
 
-  return OK;
+  DEBUGASSERT(ret == OK || ret == -EINTR);
+  return ret;
 }
 
 /****************************************************************************
diff --git a/drivers/input/button_upper.c b/drivers/input/button_upper.c
index bdbd2bfdf8..5f04eacb0f 100644
--- a/drivers/input/button_upper.c
+++ b/drivers/input/button_upper.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/input/button_upper.c
  *
- *   Copyright (C) 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -176,18 +176,18 @@ static const struct file_operations btn_fops =
 
 static inline int btn_takesem(sem_t *sem)
 {
+  int ret;
+
   /* Take a count from the semaphore, possibly waiting */
 
-  if (sem_wait(sem) < 0)
-    {
-      /* EINTR is the only error that we expect */
+  ret = nxsem_wait(sem);
 
-      int errcode = get_errno();
-      DEBUGASSERT(errcode == EINTR);
-      return -errcode;
-    }
+  /* The only case that an error should occur here is if the wait
+   * was awakened by a signal
+   */
 
-  return OK;
+  DEBUGASSERT(ret == OK || ret == -EINTR);
+  return ret;
 }
 
 /****************************************************************************
diff --git a/drivers/input/cypress_mbr3108.c b/drivers/input/cypress_mbr3108.c
index 23d5cc3cd2..881c770b72 100644
--- a/drivers/input/cypress_mbr3108.c
+++ b/drivers/input/cypress_mbr3108.c
@@ -751,7 +751,7 @@ static ssize_t mbr3108_read(FAR struct file *filep, FAR char *buffer,
   DEBUGASSERT(inode && inode->i_private);
   priv = inode->i_private;
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       return ret;
@@ -803,7 +803,7 @@ static ssize_t mbr3108_write(FAR struct file *filep, FAR const char *buffer,
       return -EINVAL;
     }
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       return ret;
@@ -879,10 +879,19 @@ static int mbr3108_open(FAR struct file *filep)
   DEBUGASSERT(inode && inode->i_private);
   priv = inode->i_private;
 
-  while (sem_wait(&priv->devsem) != 0)
+  do
     {
-      assert(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->devsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   use_count = priv->cref + 1;
   if (use_count == 1)
@@ -951,10 +960,19 @@ static int mbr3108_close(FAR struct file *filep)
   DEBUGASSERT(inode && inode->i_private);
   priv = inode->i_private;
 
-  while (sem_wait(&priv->devsem) != 0)
+  do
     {
-      assert(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->devsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   use_count = priv->cref - 1;
   if (use_count == 0)
@@ -1022,7 +1040,7 @@ static int mbr3108_poll(FAR struct file *filep, FAR struct pollfd *fds,
   DEBUGASSERT(inode && inode->i_private);
   priv = (FAR struct mbr3108_dev_s *)inode->i_private;
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       return ret;
diff --git a/drivers/input/djoystick.c b/drivers/input/djoystick.c
index a517f16e8d..b7548c6d0d 100644
--- a/drivers/input/djoystick.c
+++ b/drivers/input/djoystick.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/djoystick.c
  *
- *   Copyright (C) 2014 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -180,18 +180,18 @@ static const struct file_operations djoy_fops =
 
 static inline int djoy_takesem(sem_t *sem)
 {
+  int ret;
+
   /* Take a count from the semaphore, possibly waiting */
 
-  if (sem_wait(sem) < 0)
-    {
-      /* EINTR is the only error that we expect */
+  ret = nxsem_wait(sem);
 
-      int errcode = get_errno();
-      DEBUGASSERT(errcode == EINTR);
-      return -errcode;
-    }
+  /* The only case that an error should occur here is if the wait
+   * was awakened by a signal
+   */
 
-  return OK;
+  DEBUGASSERT(ret == OK || ret == -EINTR);
+  return ret;
 }
 
 /****************************************************************************
diff --git a/drivers/input/max11802.c b/drivers/input/max11802.c
index bde0b625a3..1e40178df0 100644
--- a/drivers/input/max11802.c
+++ b/drivers/input/max11802.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/input/max11802.c
  *
- *   Copyright (C) 2011-2012, 2014-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011-2012, 2014-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *            Petteri Aimonen <jpa@nx.mail.kapsi.fi>
  *
@@ -385,7 +385,7 @@ static int max11802_waitsample(FAR struct max11802_dev_s *priv,
 
       iinfo("Waiting..\n");
       priv->nwaiters++;
-      ret = sem_wait(&priv->waitsem);
+      ret = nxsem_wait(&priv->waitsem);
       priv->nwaiters--;
 
       if (ret < 0)
@@ -394,9 +394,8 @@ static int max11802_waitsample(FAR struct max11802_dev_s *priv,
            * the failure now.
            */
 
-          ierr("ERROR: sem_wait: %d\n", errno);
-          DEBUGASSERT(errno == EINTR);
-          ret = -EINTR;
+          ierr("ERROR: nxsem_wait: %d\n", ret);
+          DEBUGASSERT(ret == -EINTR);
           goto errout;
         }
     }
@@ -408,7 +407,7 @@ static int max11802_waitsample(FAR struct max11802_dev_s *priv,
    * sample.  Interrupts and pre-emption will be re-enabled while we wait.
    */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
 
 errout:
   /* Then re-enable interrupts.  We might get interrupt here and there
@@ -524,15 +523,15 @@ static void max11802_worker(FAR void *arg)
 
   do
     {
-      ret = sem_wait(&priv->devsem);
+      ret = nxsem_wait(&priv->devsem);
 
       /* This should only fail if the wait was cancelled by an signal
        * (and the worker thread will receive a lot of signals).
        */
 
-      DEBUGASSERT(ret == OK || errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 
   /* Check for pen up or down by reading the PENIRQ GPIO. */
 
@@ -769,13 +768,13 @@ static int max11802_open(FAR struct file *filep)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Increment the reference count */
@@ -826,13 +825,13 @@ static int max11802_close(FAR struct file *filep)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Decrement the reference count unless it would decrement a negative
@@ -887,14 +886,14 @@ static ssize_t max11802_read(FAR struct file *filep, FAR char *buffer,
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was cancelled by an signal */
 
-      ierr("ERROR: sem_wait: %d\n", errno);
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      ierr("ERROR: nxsem_wait: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Try to read sample data. */
@@ -1000,13 +999,13 @@ static int max11802_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Process the IOCTL by command */
@@ -1060,13 +1059,13 @@ static int max11802_poll(FAR struct file *filep, FAR struct pollfd *fds,
 
   /* Are we setting up the poll?  Or tearing it down? */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   if (setup)
diff --git a/drivers/input/mxt.c b/drivers/input/mxt.c
index c3ff89366b..98f4237368 100644
--- a/drivers/input/mxt.c
+++ b/drivers/input/mxt.c
@@ -708,7 +708,7 @@ static inline int mxt_waitsample(FAR struct mxt_dev_s *priv)
       /* Wait for a change in the maXTouch state */
 
       priv->nwaiters++;
-      ret = sem_wait(&priv->waitsem);
+      ret = nxsem_wait(&priv->waitsem);
       priv->nwaiters--;
 
       if (ret < 0)
@@ -717,8 +717,7 @@ static inline int mxt_waitsample(FAR struct mxt_dev_s *priv)
            * the failure now.
            */
 
-          DEBUGASSERT(errno == EINTR);
-          ret = -EINTR;
+          DEBUGASSERT(ret == -EINTR);
           goto errout;
         }
     }
@@ -728,7 +727,7 @@ static inline int mxt_waitsample(FAR struct mxt_dev_s *priv)
    * Interrupts and pre-emption will be re-enabled while we wait.
    */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
 
 errout:
   /* Then re-enable interrupts.  We might get interrupt here and there
@@ -1001,10 +1000,10 @@ static void mxt_worker(FAR void *arg)
 
   do
     {
-      ret = sem_wait(&priv->devsem);
-      DEBUGASSERT(ret == 0 || errno == EINTR);
+      ret = nxsem_wait(&priv->devsem);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 
   /* Loop, processing each message from the maXTouch */
 
@@ -1143,13 +1142,13 @@ static int mxt_open(FAR struct file *filep)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was cancelled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Increment the reference count */
@@ -1224,13 +1223,13 @@ static int mxt_close(FAR struct file *filep)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was cancelled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Decrement the reference count unless it would decrement a negative
@@ -1295,13 +1294,13 @@ static ssize_t mxt_read(FAR struct file *filep, FAR char *buffer, size_t len)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was cancelled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Locking the scheduler will prevent the worker thread from running
@@ -1517,13 +1516,13 @@ static int mxt_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was cancelled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Process the IOCTL by command */
@@ -1578,13 +1577,13 @@ static int mxt_poll(FAR struct file *filep, FAR struct pollfd *fds,
 
   /* Are we setting up the poll?  Or tearing it down? */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was cancelled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   if (setup)
diff --git a/drivers/input/stmpe811_adc.c b/drivers/input/stmpe811_adc.c
index f6a138a6cc..cd17421384 100644
--- a/drivers/input/stmpe811_adc.c
+++ b/drivers/input/stmpe811_adc.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/input/stmpe811_adc.c
  *
- *   Copyright (C) 2012 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References:
@@ -97,12 +97,11 @@ int stmpe811_adcinitialize(STMPE811_HANDLE handle)
 
   /* Get exclusive access to the device structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      int errval = errno;
-      ierr("ERROR: sem_wait failed: %d\n", errval);
-      return -errval;
+      ierr("ERROR: nxsem_wait failed: %d\n", ret);
+      return ret;
     }
 
   /* Enable Clocking for ADC */
@@ -157,12 +156,11 @@ int stmpe811_adcconfig(STMPE811_HANDLE handle, int pin)
 
   /* Get exclusive access to the device structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      int errval = errno;
-      ierr("ERROR: sem_wait failed: %d\n", errval);
-      return -errval;
+      ierr("ERROR: nxsem_wait failed: %d\n", ret);
+      return ret;
     }
 
   /* Make sure that the pin is not already in use */
@@ -217,12 +215,11 @@ uint16_t stmpe811_adcread(STMPE811_HANDLE handle, int pin)
 
   /* Get exclusive access to the device structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      int errval = errno;
-      ierr("ERROR: sem_wait failed: %d\n", errval);
-      return -errval;
+      ierr("ERROR: nxsem_wait failed: %d\n", ret);
+      return ret;
     }
 
   /* Request AD conversion by setting the bit corresponding the pin in the
diff --git a/drivers/input/stmpe811_gpio.c b/drivers/input/stmpe811_gpio.c
index d55bfe2d60..907c250deb 100644
--- a/drivers/input/stmpe811_gpio.c
+++ b/drivers/input/stmpe811_gpio.c
@@ -140,12 +140,11 @@ int stmpe811_gpioconfig(STMPE811_HANDLE handle, uint8_t pinconfig)
 
   /* Get exclusive access to the device structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      int errval = errno;
-      ierr("ERROR: sem_wait failed: %d\n", errval);
-      return -errval;
+      ierr("ERROR: nxsem_wait failed: %d\n", ret);
+      return ret;
     }
 
   /* Make sure that the pin is not already in use */
@@ -256,10 +255,10 @@ void stmpe811_gpiowrite(STMPE811_HANDLE handle, uint8_t pinconfig, bool value)
 
   /* Get exclusive access to the device structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      ierr("ERROR: sem_wait failed: %d\n", errno);
+      ierr("ERROR: nxsem_wait failed: %d\n", ret);
       return;
     }
 
@@ -309,12 +308,11 @@ int stmpe811_gpioread(STMPE811_HANDLE handle, uint8_t pinconfig, bool *value)
 
   /* Get exclusive access to the device structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      int errval = errno;
-      ierr("ERROR: sem_wait failed: %d\n", errval);
-      return -errval;
+      ierr("ERROR: nxsem_wait failed: %d\n", ret);
+      return ret;
     }
 
   regval  = stmpe811_getreg8(priv, STMPE811_GPIO_MPSTA);
@@ -358,12 +356,11 @@ int stmpe811_gpioattach(STMPE811_HANDLE handle, uint8_t pinconfig,
 
   /* Get exclusive access to the device structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      int errval = errno;
-      ierr("ERROR: sem_wait failed: %d\n", errval);
-      return -errval;
+      ierr("ERROR: nxsem_wait failed: %d\n", ret);
+      return ret;
     }
 
   /* Make sure that the GPIO interrupt system has been gpioinitialized */
diff --git a/drivers/input/stmpe811_tsc.c b/drivers/input/stmpe811_tsc.c
index 9473568186..42c374c5b0 100644
--- a/drivers/input/stmpe811_tsc.c
+++ b/drivers/input/stmpe811_tsc.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/input/stmpe811_tsc.c
  *
- *   Copyright (C) 2012 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References:
@@ -300,26 +300,19 @@ static inline int stmpe811_waitsample(FAR struct stmpe811_dev_s *priv,
       /* Wait for a change in the STMPE811 state */
 
       priv->nwaiters++;
-      ret = sem_wait(&priv->waitsem);
+      ret = nxsem_wait(&priv->waitsem);
       priv->nwaiters--;
 
       /* When we are re-awakened, pre-emption will again be disabled */
 
       if (ret < 0)
         {
-#if defined(CONFIG_DEBUG_INPUT_ERROR) || defined(CONFIG_DEBUG_ASSERTIONS)
-          /* Sample the errno (debug output could change it) */
-
-          int errval = errno;
-
           /* If we are awakened by a signal, then we need to return
            * the failure now.
            */
 
-          ierr("ERROR: sem_wait failed: %d\n", errval);
-          DEBUGASSERT(errval == EINTR);
-#endif
-          ret = -EINTR;
+          ierr("ERROR: nxsem_wait failed: %d\n", ret);
+          DEBUGASSERT(ret == -EINTR);
           goto errout;
         }
     }
@@ -329,7 +322,7 @@ static inline int stmpe811_waitsample(FAR struct stmpe811_dev_s *priv,
    * Interrupts and pre-emption will be re-enabled while we wait.
    */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
 
 errout:
   /* Restore pre-emption.  We might get suspended here but that is okay
@@ -366,13 +359,14 @@ static int stmpe811_open(FAR struct file *filep)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was cancelled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      ierr("ERROR: nxsem_wait failed: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Increment the reference count */
@@ -425,13 +419,14 @@ static int stmpe811_close(FAR struct file *filep)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      ierr("ERROR: nxsem_wait failed: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Decrement the reference count unless it would decrement a negative
@@ -487,13 +482,14 @@ static ssize_t stmpe811_read(FAR struct file *filep, FAR char *buffer, size_t le
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      ierr("ERROR: nxsem_wait failed: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Try to read sample data. */
@@ -601,13 +597,14 @@ static int stmpe811_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      ierr("ERROR: nxsem_wait failed: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Process the IOCTL by command */
@@ -665,13 +662,14 @@ static int stmpe811_poll(FAR struct file *filep, FAR struct pollfd *fds,
 
   /* Are we setting up the poll?  Or tearing it down? */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      ierr("ERROR: nxsem_wait failed: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   if (setup)
@@ -906,12 +904,12 @@ int stmpe811_register(STMPE811_HANDLE handle, int minor)
 
   /* Get exclusive access to the device structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      int errval = errno;
-      ierr("ERROR: sem_wait failed: %d\n", errval);
-      return -errval;
+      ierr("ERROR: nxsem_wait failed: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Make sure that the pins (4-7) need by the TSC are not already in use */
diff --git a/drivers/input/tsc2007.c b/drivers/input/tsc2007.c
index c9ab51117d..a2f63338bc 100644
--- a/drivers/input/tsc2007.c
+++ b/drivers/input/tsc2007.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/input/tsc2007.c
  *
- *   Copyright (C) 2011-2012, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011-2012, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References:
@@ -377,7 +377,7 @@ static int tsc2007_waitsample(FAR struct tsc2007_dev_s *priv,
       /* Wait for a change in the TSC2007 state */
 
       priv->nwaiters++;
-      ret = sem_wait(&priv->waitsem);
+      ret = nxsem_wait(&priv->waitsem);
       priv->nwaiters--;
 
       if (ret < 0)
@@ -386,8 +386,8 @@ static int tsc2007_waitsample(FAR struct tsc2007_dev_s *priv,
            * the failure now.
            */
 
-          DEBUGASSERT(errno == EINTR);
-          ret = -EINTR;
+          ierr("ERROR: nxsem_wait failed: %d\n", ret);
+          DEBUGASSERT(ret == -EINTR);
           goto errout;
         }
     }
@@ -397,7 +397,7 @@ static int tsc2007_waitsample(FAR struct tsc2007_dev_s *priv,
    * Interrupts and pre-emption will be re-enabled while we wait.
    */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
 
 errout:
   /* Then re-enable interrupts.  We might get interrupt here and there
@@ -815,13 +815,14 @@ static int tsc2007_open(FAR struct file *filep)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was cancelled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      ierr("ERROR: nxsem_wait failed: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Increment the reference count */
@@ -870,13 +871,14 @@ static int tsc2007_close(FAR struct file *filep)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was cancelled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      ierr("ERROR: nxsem_wait failed: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Decrement the reference count unless it would decrement a negative
@@ -927,13 +929,14 @@ static ssize_t tsc2007_read(FAR struct file *filep, FAR char *buffer, size_t len
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was cancelled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      ierr("ERROR: nxsem_wait failed: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Try to read sample data. */
@@ -1043,13 +1046,14 @@ static int tsc2007_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was cancelled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      ierr("ERROR: nxsem_wait failed: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Process the IOCTL by command */
@@ -1119,13 +1123,14 @@ static int tsc2007_poll(FAR struct file *filep, FAR struct pollfd *fds,
 
   /* Are we setting up the poll?  Or tearing it down? */
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was cancelled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      ierr("ERROR: nxsem_wait failed: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   if (setup)
diff --git a/drivers/ioexpander/pca9555.c b/drivers/ioexpander/pca9555.c
index 90fad63c9c..454a7e2a32 100644
--- a/drivers/ioexpander/pca9555.c
+++ b/drivers/ioexpander/pca9555.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/ioexpander/pca9555.c
  *
- *   Copyright (C) 2015, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Sebastien Lorquet <sebastien@lorquet.fr>
  *
  * References:
@@ -150,12 +150,21 @@ static const struct ioexpander_ops_s g_pca9555_ops =
 
 static void pca9555_lock(FAR struct pca9555_dev_s *pca)
 {
-  while (sem_wait(&pca->exclsem) < 0)
-    {
-      /* EINTR is the only expected error from sem_wait() */
+  int ret;
 
-      DEBUGASSERT(errno == EINTR);
+  do
+    {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&pca->exclsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 #define pca9555_unlock(p) nxsem_post(&(p)->exclsem)
diff --git a/drivers/ioexpander/pcf8574.c b/drivers/ioexpander/pcf8574.c
index f1602bd543..56baaa7e8a 100644
--- a/drivers/ioexpander/pcf8574.c
+++ b/drivers/ioexpander/pcf8574.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/ioexpander/pcf8574.h
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -154,12 +154,21 @@ static const struct ioexpander_ops_s g_pcf8574_ops =
 
 static void pcf8574_lock(FAR struct pcf8574_dev_s *priv)
 {
-  while (sem_wait(&priv->exclsem) < 0)
-    {
-      /* EINTR is the only expected error from sem_wait() */
+  int ret;
 
-      DEBUGASSERT(errno == EINTR);
+  do
+    {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->exclsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 #define pcf8574_unlock(p) nxsem_post(&(p)->exclsem)
diff --git a/drivers/ioexpander/skeleton.c b/drivers/ioexpander/skeleton.c
index b30f688e8c..2dda5a219a 100644
--- a/drivers/ioexpander/skeleton.c
+++ b/drivers/ioexpander/skeleton.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/ioexpander/skeleton.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org
  *
  * Redistribution and use in source and binary forms, with or without
@@ -168,12 +168,21 @@ static const struct ioexpander_ops_s g_skel_ops =
 
 static void skel_lock(FAR struct skel_dev_s *priv)
 {
-  while (sem_wait(&priv->exclsem) < 0)
-    {
-      /* EINTR is the only expected error from sem_wait() */
+  int ret;
 
-      DEBUGASSERT(errno == EINTR);
+  do
+    {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->exclsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 #define skel_unlock(p) nxsem_post(&(p)->exclsem)
diff --git a/drivers/ioexpander/tca64xx.c b/drivers/ioexpander/tca64xx.c
index 2af000e0c1..e4ca94f72a 100644
--- a/drivers/ioexpander/tca64xx.c
+++ b/drivers/ioexpander/tca64xx.c
@@ -2,7 +2,7 @@
  * drivers/ioexpander/tca64xx.h
  * Supports the following parts: TCA6408, TCA6416, TCA6424
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * This header file derives, in part, from the Project Ara TCA64xx driver
@@ -197,12 +197,21 @@ static const struct tca64_part_s g_tca64_parts[TCA64_NPARTS] =
 
 static void tca64_lock(FAR struct tca64_dev_s *priv)
 {
-  while (sem_wait(&priv->exclsem) < 0)
-    {
-      /* EINTR is the only expected error from sem_wait() */
+  int ret;
 
-      DEBUGASSERT(errno == EINTR);
+  do
+    {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->exclsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 #define tca64_unlock(p) nxsem_post(&(p)->exclsem)
diff --git a/drivers/lcd/pcf8574_lcd_backpack.c b/drivers/lcd/pcf8574_lcd_backpack.c
index ffc8ee81a5..44578f9a7f 100644
--- a/drivers/lcd/pcf8574_lcd_backpack.c
+++ b/drivers/lcd/pcf8574_lcd_backpack.c
@@ -1065,7 +1065,7 @@ static int pcf8574_lcd_open(FAR struct file *filep)
 
   /* Increment the reference count */
 
-  sem_wait(&priv->sem_excl);
+  nxsem_wait(&priv->sem_excl);
   if (priv->refs == MAX_OPENCNT)
     {
       return -EMFILE;
@@ -1095,7 +1095,7 @@ static int pcf8574_lcd_close(FAR struct file *filep)
 
   /* Decrement the reference count */
 
-  sem_wait(&priv->sem_excl);
+  nxsem_wait(&priv->sem_excl);
 
   if (priv->refs == 0)
     {
@@ -1141,7 +1141,7 @@ static ssize_t pcf8574_lcd_read(FAR struct file *filep, FAR char *buffer,
   uint8_t col;
   bool onlf;
 
-  sem_wait(&priv->sem_excl);
+  nxsem_wait(&priv->sem_excl);
 
   /* Get current cursor position so we can restore it */
 
@@ -1224,7 +1224,7 @@ static ssize_t pcf8574_lcd_write(FAR struct file *filep,
   uint8_t ch;
   uint8_t count;
 
-  sem_wait(&priv->sem_excl);
+  nxsem_wait(&priv->sem_excl);
 
   /* Initialize the stream for use with the SLCD CODEC */
 
@@ -1372,7 +1372,7 @@ static off_t pcf8574_lcd_seek(FAR struct file *filep, off_t offset, int whence)
   FAR struct pcf8574_lcd_dev_s *priv = (FAR struct pcf8574_lcd_dev_s *)inode->i_private;
   int maxpos;
 
-  sem_wait(&priv->sem_excl);
+  nxsem_wait(&priv->sem_excl);
 
   maxpos = priv->cfg.rows * priv->cfg.cols + (priv->cfg.rows - 1);
   switch (whence)
@@ -1444,7 +1444,7 @@ static int pcf8574_lcd_ioctl(FAR struct file *filep, int cmd,
           uint8_t row;
           uint8_t col;
 
-          sem_wait(&priv->sem_excl);
+          nxsem_wait(&priv->sem_excl);
 
           lcd_get_curpos(priv, &row, &col);
           attr->row = row;
@@ -1470,7 +1470,7 @@ static int pcf8574_lcd_ioctl(FAR struct file *filep, int cmd,
           FAR struct inode *inode = filep->f_inode;
           FAR struct pcf8574_lcd_dev_s *priv = (FAR struct pcf8574_lcd_dev_s *)inode->i_private;
 
-          sem_wait(&priv->sem_excl);
+          nxsem_wait(&priv->sem_excl);
           lcd_backlight(priv, arg ? true : false);
           nxsem_post(&priv->sem_excl);
         }
@@ -1482,7 +1482,7 @@ static int pcf8574_lcd_ioctl(FAR struct file *filep, int cmd,
           FAR struct pcf8574_lcd_dev_s *priv = (FAR struct pcf8574_lcd_dev_s *)inode->i_private;
           FAR struct slcd_createchar_s *attr = (FAR struct slcd_createchar_s *)((uintptr_t)arg);
 
-          sem_wait(&priv->sem_excl);
+          nxsem_wait(&priv->sem_excl);
           lcd_create_char(priv, attr->idx, attr->bmp);
           nxsem_post(&priv->sem_excl);
         }
@@ -1531,7 +1531,7 @@ static int pcf8574_lcd_unlink(FAR struct inode *inode)
   FAR struct pcf8574_lcd_dev_s *priv = (FAR struct pcf8574_lcd_dev_s *)inode->i_private;
   int ret = OK;
 
-  sem_wait(&priv->sem_excl);
+  nxsem_wait(&priv->sem_excl);
 
   priv->unlinked = true;
 
diff --git a/drivers/leds/rgbled.c b/drivers/leds/rgbled.c
index 4c89bd2335..0ba2229bdb 100644
--- a/drivers/leds/rgbled.c
+++ b/drivers/leds/rgbled.c
@@ -135,10 +135,11 @@ static int rgbled_open(FAR struct file *filep)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&upper->exclsem);
+  ret = nxsem_wait(&upper->exclsem);
   if (ret < 0)
     {
-      ret = -get_errno();
+      lcderr("ERROR: nxsem_wait failed: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
       goto errout;
     }
 
@@ -186,10 +187,11 @@ static int rgbled_close(FAR struct file *filep)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&upper->exclsem);
+  ret = nxsem_wait(&upper->exclsem);
   if (ret < 0)
     {
-      ret = -get_errno();
+      lcderr("ERROR: nxsem_wait failed: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
       goto errout;
     }
 
diff --git a/drivers/leds/userled_upper.c b/drivers/leds/userled_upper.c
index ff6829010b..f851f33cce 100644
--- a/drivers/leds/userled_upper.c
+++ b/drivers/leds/userled_upper.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/leds/userled_upper.c
  *
- *   Copyright (C) 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -141,18 +141,18 @@ static const struct file_operations userled_fops =
 
 static inline int userled_takesem(sem_t *sem)
 {
+  int ret;
+
   /* Take a count from the semaphore, possibly waiting */
 
-  if (sem_wait(sem) < 0)
-    {
-      /* EINTR is the only error that we expect */
+  ret = nxsem_wait(sem);
 
-      int errcode = get_errno();
-      DEBUGASSERT(errcode == EINTR);
-      return -errcode;
-    }
+  /* The only case that an error should occur here is if the wait
+   * was awakened by a signal
+   */
 
-  return OK;
+  DEBUGASSERT(ret == OK || ret == -EINTR);
+  return ret;
 }
 
 /****************************************************************************
diff --git a/drivers/loop/losetup.c b/drivers/loop/losetup.c
index f0a2d2aedc..f5d2969a6f 100644
--- a/drivers/loop/losetup.c
+++ b/drivers/loop/losetup.c
@@ -1,7 +1,8 @@
 /****************************************************************************
  * drivers/loop/losetup.c
  *
- *   Copyright (C) 2008-2009, 2011, 2014-2015 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2008-2009, 2011, 2014-2015, 2017 Gregory Nutt. All
+ *     rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -136,20 +137,14 @@ static int loop_semtake(FAR struct loop_struct_s *dev)
 
   /* Take the semaphore (perhaps waiting) */
 
-  ret = sem_wait(&dev->sem);
-  if (ret < 0)
-    {
-      int errcode = get_errno();
+  ret = nxsem_wait(&dev->sem);
 
-      /* The only case that an error should occur here is if
-       * the wait was awakened by a signal.
-       */
+  /* The only case that an error should occur here is if the wait was
+   * awakened by a signal.
+   */
 
-      ASSERT(errcode == EINTR);
-      return -ret;
-    }
-
-  return OK;
+  DEBUGASSERT(ret == -EINTR);
+  return ret;
 }
 
 /****************************************************************************
diff --git a/drivers/mmcsd/mmcsd_sdio.c b/drivers/mmcsd/mmcsd_sdio.c
index dda0b92117..b1b87c27e3 100644
--- a/drivers/mmcsd/mmcsd_sdio.c
+++ b/drivers/mmcsd/mmcsd_sdio.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/mmcsd/mmcsd_sdio.c
  *
- *   Copyright (C) 2009-2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2009-2013, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -279,18 +279,23 @@ static const struct block_operations g_bops =
 
 static void mmcsd_takesem(FAR struct mmcsd_state_s *priv)
 {
+  int ret;
+
   /* Take the semaphore, giving exclusive access to the driver (perhaps
    * waiting)
    */
 
-  while (sem_wait(&priv->sem) != 0)
+  do
     {
+      ret = nxsem_wait(&priv->sem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   /* Lock the bus if mutually exclusive access to the SDIO bus is required
    * on this platform.
diff --git a/drivers/mmcsd/mmcsd_spi.c b/drivers/mmcsd/mmcsd_spi.c
index 4ef5eb17ba..d59b868149 100644
--- a/drivers/mmcsd/mmcsd_spi.c
+++ b/drivers/mmcsd/mmcsd_spi.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/mmcsd/mmcsd_spi.c
  *
- *   Copyright (C) 2008-2010, 2011-2013 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2008-2010, 2011-2013, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -354,6 +354,8 @@ static const struct mmcsd_cmdinfo_s g_acmd41 = {ACMD41, MMCSD_CMDRESP_R1, 0xff};
 
 static void mmcsd_semtake(FAR struct mmcsd_slot_s *slot)
 {
+  int ret;
+
   /* Get exclusive access to the SPI bus (if necessary) */
 
   (void)SPI_LOCK(slot->spi, true);
@@ -371,14 +373,19 @@ static void mmcsd_semtake(FAR struct mmcsd_slot_s *slot)
    * SPI_LOCK is also implemented as a semaphore).
    */
 
-  while (sem_wait(&slot->sem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&slot->sem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/drivers/mtd/mtd_config.c b/drivers/mtd/mtd_config.c
index 014cc86e57..9a0d4077c1 100644
--- a/drivers/mtd/mtd_config.c
+++ b/drivers/mtd/mtd_config.c
@@ -934,10 +934,11 @@ static int  mtdconfig_open(FAR struct file *filep)
 
   /* Get exclusive access to the device */
 
-  ret = sem_wait(&dev->exclsem);
+  ret = nxsem_wait(&dev->exclsem);
   if (ret < 0)
     {
-      ret = -errno;
+      ferr("ERROR: nxsem_wait failed: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
       goto errout;
     }
 
@@ -1015,7 +1016,8 @@ static int mtdconfig_findentry(FAR struct mtdconfig_struct_s *dev,
     }
 #endif
 
-  while (offset > 0 && (pdata->id != phdr->id || pdata->instance != phdr->instance))
+  while (offset > 0 && (pdata->id != phdr->id ||
+         pdata->instance != phdr->instance))
     {
       if (phdr->id == MTD_ERASED_ID)
         {
diff --git a/drivers/mtd/mtd_nand.c b/drivers/mtd/mtd_nand.c
index d57764d933..8394af67de 100644
--- a/drivers/mtd/mtd_nand.c
+++ b/drivers/mtd/mtd_nand.c
@@ -147,17 +147,9 @@ static int nand_lock(FAR struct nand_dev_s *nand)
   int errcode;
   int ret;
 
-  ret = sem_wait(&nand->exclsem);
-  if (ret < 0)
-    {
-      errcode = errno;
-      DEBUGASSERT(errcode != OK);
-
-      ferr("ERROR: sem_wait failed: %d\n", errcode);
-      return -errcode;
-    }
-
-  return OK;
+  ret = nxsem_wait(&nand->exclsem);
+  DEBUGASSERT(ret == OK || ret == -EINTR);
+  return ret;
 }
 
 /****************************************************************************
diff --git a/drivers/net/phy_notify.c b/drivers/net/phy_notify.c
index a680623ff0..3c21eb5e5a 100644
--- a/drivers/net/phy_notify.c
+++ b/drivers/net/phy_notify.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/net/phy_notify.c
  *
- *   Copyright (C) 2014 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -139,16 +139,21 @@ static struct phy_notify_s g_notify_clients[CONFIG_PHY_NOTIFICATION_NCLIENTS];
 
 static void phy_semtake(void)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&g_notify_clients_sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if
-       * the wait was awakened by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&g_notify_clients_sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      DEBUGASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 #define phy_semgive() nxsem_post(&g_notify_clients_sem);
diff --git a/drivers/net/slip.c b/drivers/net/slip.c
index 032133f591..bbd4cd357c 100644
--- a/drivers/net/slip.c
+++ b/drivers/net/slip.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/net/slip.c
  *
- *   Copyright (C) 2011-2012, 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011-2012, 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Reference: RFC 1055
@@ -199,16 +199,21 @@ static int slip_rmmac(FAR struct net_driver_s *dev, FAR const uint8_t *mac);
 
 static void slip_semtake(FAR struct slip_driver_s *priv)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&priv->waitsem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if
-       * the wait was awakened by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->waitsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 #define slip_semgive(p) nxsem_post(&(p)->waitsem);
diff --git a/drivers/net/telnet.c b/drivers/net/telnet.c
index 2810bffcef..8ec933c975 100644
--- a/drivers/net/telnet.c
+++ b/drivers/net/telnet.c
@@ -478,10 +478,11 @@ static int telnet_open(FAR struct file *filep)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&priv->td_exclsem);
+  ret = nxsem_wait(&priv->td_exclsem);
   if (ret < 0)
     {
-      ret = -errno;
+      nerr("ERROR: nxsem_wait failed: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
       goto errout;
     }
 
@@ -526,10 +527,11 @@ static int telnet_close(FAR struct file *filep)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&priv->td_exclsem);
+  ret = nxsem_wait(&priv->td_exclsem);
   if (ret < 0)
     {
-      ret = -errno;
+      nerr("ERROR: nxsem_wait failed: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
       goto errout;
     }
 
@@ -810,13 +812,14 @@ static int telnet_session(FAR struct telnet_session_s *session)
 
   do
     {
-      ret = sem_wait(&g_telnet_common.tc_exclsem);
-      if (ret < 0 && errno != -EINTR)
+      ret = nxsem_wait(&g_telnet_common.tc_exclsem);
+      if (ret < 0 && ret != -EINTR)
         {
+          nerr("ERROR: nxsem_wait failed: %d\n", ret);
           goto errout_with_clone;
         }
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 
   /* Loop until the device name is verified to be unique. */
 
diff --git a/drivers/net/tun.c b/drivers/net/tun.c
index 72e317f4ae..6c5beeba5e 100644
--- a/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@ -229,16 +229,21 @@ static const struct file_operations g_tun_file_ops =
 
 static void tundev_lock(FAR struct tun_driver_s *tun)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&tun->waitsem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if
-       * the wait was awakened by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&tun->waitsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
@@ -256,16 +261,21 @@ static void tundev_unlock(FAR struct tun_driver_s *tun)
 
 static void tun_lock(FAR struct tun_device_s *priv)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&priv->waitsem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if
-       * the wait was awakened by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->waitsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
@@ -1076,7 +1086,7 @@ static ssize_t tun_read(FAR struct file *filep, FAR char *buffer,
 
       priv->read_wait = true;
       tun_unlock(priv);
-      sem_wait(&priv->read_wait_sem);
+      (void)nxsem_wait(&priv->read_wait_sem);
       tun_lock(priv);
     }
 
diff --git a/drivers/pipes/pipe.c b/drivers/pipes/pipe.c
index 86cdfcca4f..b32ef965e9 100644
--- a/drivers/pipes/pipe.c
+++ b/drivers/pipes/pipe.c
@@ -128,8 +128,8 @@ static inline void pipe_free(int pipeno)
 {
   int ret;
 
-  ret = sem_wait(&g_pipesem);
-  if (ret == 0)
+  ret = nxsem_wait(&g_pipesem);
+  if (ret == OK)
     {
       g_pipeset &= ~(1 << pipeno);
       (void)nxsem_post(&g_pipesem);
@@ -198,12 +198,11 @@ int pipe2(int fd[2], size_t bufsize)
 
   /* Get exclusive access to the pipe allocation data */
 
-  ret = sem_wait(&g_pipesem);
+  ret = nxsem_wait(&g_pipesem);
   if (ret < 0)
     {
-      /* sem_wait() will have already set errno */
-
-      return ERROR;
+      errcode = -ret;
+      goto errout;
     }
 
   /* Allocate a minor number for the pipe device */
diff --git a/drivers/pipes/pipe_common.c b/drivers/pipes/pipe_common.c
index 186a26937d..03509461e3 100644
--- a/drivers/pipes/pipe_common.c
+++ b/drivers/pipes/pipe_common.c
@@ -95,14 +95,21 @@ static void pipecommon_semtake(sem_t *sem);
 
 static void pipecommon_semtake(FAR sem_t *sem)
 {
-  while (sem_wait(sem) != 0)
+  int ret;
+
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(get_errno() == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
@@ -212,15 +219,14 @@ int pipecommon_open(FAR struct file *filep)
   DEBUGASSERT(dev != NULL);
 
   /* Make sure that we have exclusive access to the device structure.  The
-   * sem_wait() call should fail only if we are awakened by a signal.
+   * nxsem_wait() call should fail only if we are awakened by a signal.
    */
 
-  ret = sem_wait(&dev->d_bfsem);
-  if (ret != OK)
+  ret = nxsem_wait(&dev->d_bfsem);
+  if (ret < 0)
     {
-      ferr("ERROR: sem_wait failed: %d\n", get_errno());
-      DEBUGASSERT(get_errno() > 0);
-      return -get_errno();
+      ferr("ERROR: nxsem_wait failed: %d\n", ret);
+      return ret;
     }
 
   /* If this the first reference on the device, then allocate the buffer.
@@ -289,16 +295,14 @@ int pipecommon_open(FAR struct file *filep)
        * no writer on the pipe.
        */
 
-      ret = sem_wait(&dev->d_rdsem);
-      if (ret != OK)
+      ret = nxsem_wait(&dev->d_rdsem);
+      if (ret < 0)
         {
-          /* The sem_wait() call should fail only if we are awakened by
+          /* The nxsem_wait() call should fail only if we are awakened by
            * a signal.
            */
 
-          ferr("ERROR: sem_wait failed: %d\n", get_errno());
-          DEBUGASSERT(get_errno() > 0);
-          ret = -get_errno();
+          ferr("ERROR: nxsem_wait failed: %d\n", ret);
 
           /* Immediately close the pipe that we just opened */
 
@@ -440,9 +444,10 @@ ssize_t pipecommon_read(FAR struct file *filep, FAR char *buffer, size_t len)
 
   /* Make sure that we have exclusive access to the device structure */
 
-  if (sem_wait(&dev->d_bfsem) < 0)
+  ret = nxsem_wait(&dev->d_bfsem);
+  if (ret < 0)
     {
-      return ERROR;
+      return ret;
     }
 
   /* If the pipe is empty, then wait for something to be written to it */
@@ -469,12 +474,12 @@ ssize_t pipecommon_read(FAR struct file *filep, FAR char *buffer, size_t len)
 
       sched_lock();
       nxsem_post(&dev->d_bfsem);
-      ret = sem_wait(&dev->d_rdsem);
+      ret = nxsem_wait(&dev->d_rdsem);
       sched_unlock();
 
-      if (ret < 0 || sem_wait(&dev->d_bfsem) < 0)
+      if (ret < 0 || (ret = nxsem_wait(&dev->d_bfsem)) < 0)
         {
-          return ERROR;
+          return ret;
         }
     }
 
@@ -521,6 +526,7 @@ ssize_t pipecommon_write(FAR struct file *filep, FAR const char *buffer,
   ssize_t                last;
   int                    nxtwrndx;
   int                    sval;
+  int                    ret;
 
   DEBUGASSERT(dev);
   pipe_dumpbuffer("To PIPE:", (FAR uint8_t *)buffer, len);
@@ -530,12 +536,13 @@ ssize_t pipecommon_write(FAR struct file *filep, FAR const char *buffer,
       return 0;
     }
 
-  /* At present, this method cannot be called from interrupt handlers.  That is
-   * because it calls sem_wait (via pipecommon_semtake below) and sem_wait cannot
-   * be called from interrupt level.  This actually happens fairly commonly
-   * IF [a-z]err() is called from interrupt handlers and stdout is being redirected
-   * via a pipe.  In that case, the debug output will try to go out the pipe
-   * (interrupt handlers should use the  _err() APIs).
+  /* At present, this method cannot be called from interrupt handlers.  That
+   * is because it calls nxsem_wait (via pipecommon_semtake below) and
+   * nxsem_wait cannot be called from interrupt level.  This actually
+   * happens fairly commonly IF [a-z]err() is called from interrupt handlers
+   * and stdout is being redirected via a pipe.  In that case, the debug
+   * output will try to go out the pipe (interrupt handlers should use the
+   * _err() APIs).
    *
    * On the other hand, it would be very valuable to be able to feed the pipe
    * from an interrupt handler!  TODO:  Consider disabling interrupts instead
@@ -546,9 +553,10 @@ ssize_t pipecommon_write(FAR struct file *filep, FAR const char *buffer,
 
   /* Make sure that we have exclusive access to the device structure */
 
-  if (sem_wait(&dev->d_bfsem) < 0)
+  ret = nxsem_wait(&dev->d_bfsem);
+  if (ret < 0)
     {
-      return ERROR;
+      return ret;
     }
 
   /* Loop until all of the bytes have been written */
diff --git a/drivers/power/battery_charger.c b/drivers/power/battery_charger.c
index 264b2296cd..aa5b0c0fa9 100644
--- a/drivers/power/battery_charger.c
+++ b/drivers/power/battery_charger.c
@@ -162,10 +162,10 @@ static int bat_charger_ioctl(FAR struct file *filep, int cmd,
 
   /* Enforce mutually exclusive access to the battery driver */
 
-  ret = sem_wait(&dev->batsem);
+  ret = nxsem_wait(&dev->batsem);
   if (ret < 0)
     {
-      return -errno; /* Probably EINTR */
+      return ret; /* Probably -EINTR */
     }
 
   /* Process the IOCTL command */
diff --git a/drivers/power/battery_gauge.c b/drivers/power/battery_gauge.c
index 3860286b46..ab97489188 100644
--- a/drivers/power/battery_gauge.c
+++ b/drivers/power/battery_gauge.c
@@ -161,10 +161,10 @@ static int bat_gauge_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 
   /* Inforce mutually exclusive access to the battery driver */
 
-  ret = sem_wait(&dev->batsem);
+  ret = nxsem_wait(&dev->batsem);
   if (ret < 0)
     {
-      return -errno; /* Probably EINTR */
+      return ret; /* Probably -EINTR */
     }
 
   /* Procss the IOCTL command */
diff --git a/drivers/power/pm.h b/drivers/power/pm.h
index 850d019999..372c790034 100644
--- a/drivers/power/pm.h
+++ b/drivers/power/pm.h
@@ -81,7 +81,7 @@
  *
  ****************************************************************************/
 
-#define pm_lock() sem_wait(&g_pmglobals.regsem);
+#define pm_lock() nxsem_wait(&g_pmglobals.regsem);
 
 /****************************************************************************
  * Name: pm_unlock
diff --git a/drivers/power/pm_register.c b/drivers/power/pm_register.c
index 138eeff1cf..b33dab6962 100644
--- a/drivers/power/pm_register.c
+++ b/drivers/power/pm_register.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/power/pm_register.c
  *
- *   Copyright (C) 2011-2012 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011-2012, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/drivers/power/powerled.c b/drivers/power/powerled.c
index 3f854eb905..52996d4919 100644
--- a/drivers/power/powerled.c
+++ b/drivers/power/powerled.c
@@ -97,18 +97,15 @@ static const struct file_operations powerled_fops =
 
 static int powerled_open(FAR struct file *filep)
 {
-  FAR struct inode      *inode = filep->f_inode;
-  FAR struct powerled_dev_s *dev   = inode->i_private;
-  uint8_t                tmp;
-  int                    ret   = OK;
+  FAR struct inode *inode        = filep->f_inode;
+  FAR struct powerled_dev_s *dev = inode->i_private;
+  uint8_t tmp;
+  int ret;
 
   /* If the port is the middle of closing, wait until the close is finished */
 
-  if (sem_wait(&dev->closesem) != OK)
-    {
-      ret = -errno;
-    }
-  else
+  ret = nxsem_wait(&dev->closesem);
+  if (ret >= 0)
     {
       /* Increment the count of references to the device.  If this the first
        * time that the driver has been opened for this device, then initialize
@@ -160,16 +157,13 @@ static int powerled_open(FAR struct file *filep)
 
 static int powerled_close(FAR struct file *filep)
 {
-  FAR struct inode     *inode = filep->f_inode;
-  FAR struct powerled_dev_s *dev   = inode->i_private;
-  irqstate_t            flags;
-  int                   ret = OK;
+  FAR struct inode *inode        = filep->f_inode;
+  FAR struct powerled_dev_s *dev = inode->i_private;
+  irqstate_t flags;
+  int ret;
 
-  if (sem_wait(&dev->closesem) != OK)
-    {
-      ret = -errno;
-    }
-  else
+  ret = nxsem_wait(&dev->closesem);
+  if (ret >= 0)
     {
       /* Decrement the references to the driver.  If the reference count will
        * decrement to 0, then uninitialize the driver.
diff --git a/drivers/power/smps.c b/drivers/power/smps.c
index 9e30b3a1ba..c17cdd5fe1 100644
--- a/drivers/power/smps.c
+++ b/drivers/power/smps.c
@@ -104,15 +104,12 @@ static int smps_open(FAR struct file *filep)
   FAR struct inode      *inode = filep->f_inode;
   FAR struct smps_dev_s *dev   = inode->i_private;
   uint8_t                tmp;
-  int                    ret   = OK;
+  int                    ret;
 
   /* If the port is the middle of closing, wait until the close is finished */
 
-  if (sem_wait(&dev->closesem) != OK)
-    {
-      ret = -errno;
-    }
-  else
+  ret = nxsem_wait(&dev->closesem);
+  if (ret >= 0)
     {
       /* Increment the count of references to the device.  If this the first
        * time that the driver has been opened for this device, then initialize
@@ -164,16 +161,13 @@ static int smps_open(FAR struct file *filep)
 
 static int smps_close(FAR struct file *filep)
 {
-  FAR struct inode     *inode = filep->f_inode;
+  FAR struct inode     *inode  = filep->f_inode;
   FAR struct smps_dev_s *dev   = inode->i_private;
   irqstate_t            flags;
-  int                   ret = OK;
+  int                   ret;
 
-  if (sem_wait(&dev->closesem) != OK)
-    {
-      ret = -errno;
-    }
-  else
+  ret = nxsem_wait(&dev->closesem);
+  if (ret >= 0)
     {
       /* Decrement the references to the driver.  If the reference count will
        * decrement to 0, then uninitialize the driver.
diff --git a/drivers/pwm.c b/drivers/pwm.c
index 1429394b13..44d644cc64 100644
--- a/drivers/pwm.c
+++ b/drivers/pwm.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/pwm.c
  *
- *   Copyright (C) 2011-2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011-2013, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -169,10 +169,9 @@ static int pwm_open(FAR struct file *filep)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&upper->exclsem);
+  ret = nxsem_wait(&upper->exclsem);
   if (ret < 0)
     {
-      ret = -get_errno();
       goto errout;
     }
 
@@ -238,10 +237,9 @@ static int pwm_close(FAR struct file *filep)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&upper->exclsem);
+  ret = nxsem_wait(&upper->exclsem);
   if (ret < 0)
     {
-      ret = -get_errno();
       goto errout;
     }
 
@@ -356,7 +354,7 @@ static int pwm_start(FAR struct pwm_upperhalf_s *upper, unsigned int oflags)
       if (ret == OK)
         {
           /* Should we wait for the pulse output to complete?  Loop in
-           * in case the wakeup form sem_wait() is a false alarm.
+           * in case the wakeup form nxsem_wait() is a false alarm.
            */
 
           while (upper->waiting)
@@ -366,8 +364,8 @@ static int pwm_start(FAR struct pwm_upperhalf_s *upper, unsigned int oflags)
                * clear the waiting flag.
                */
 
-              int tmp = sem_wait(&upper->waitsem);
-              DEBUGASSERT(tmp == OK || get_errno() == EINTR);
+              int tmp = nxsem_wait(&upper->waitsem);
+              DEBUGASSERT(tmp == OK || tmp == -EINTR);
             }
         }
       else
@@ -437,7 +435,7 @@ static int pwm_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&upper->exclsem);
+  ret = nxsem_wait(&upper->exclsem);
   if (ret < 0)
     {
       return ret;
diff --git a/drivers/rwbuffer.c b/drivers/rwbuffer.c
index 8866bae0f1..6fe67bdfac 100644
--- a/drivers/rwbuffer.c
+++ b/drivers/rwbuffer.c
@@ -1,7 +1,8 @@
 /****************************************************************************
  * drivers/rwbuffer.c
  *
- *   Copyright (C) 2009, 2011, 2013-2014 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2009, 2011, 2013-2014, 2017 Gregory Nutt. All rights
+ *     reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -92,16 +93,21 @@
 
 static void rwb_semtake(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if
-       * the wait was awakened by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(get_errno() == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/drivers/sensors/adxl345_base.c b/drivers/sensors/adxl345_base.c
index 6a4b66236f..da09bb353a 100644
--- a/drivers/sensors/adxl345_base.c
+++ b/drivers/sensors/adxl345_base.c
@@ -148,13 +148,13 @@ static ssize_t adxl345_read(FAR struct file *filep, FAR char *buffer, size_t len
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Read accelerometer X Y Z axes */
@@ -205,12 +205,12 @@ int adxl345_register(ADXL345_HANDLE handle, int minor)
 
   /* Get exclusive access to the device structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      int errval = errno;
-      snerr("ERROR: sem_wait failed: %d\n", errval);
-      return -errval;
+      snerr("ERROR: nxsem_wait failed: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Initialize the structure fields to their default values */
diff --git a/drivers/sensors/bmg160.c b/drivers/sensors/bmg160.c
index af886f798c..b7cc35f8ed 100644
--- a/drivers/sensors/bmg160.c
+++ b/drivers/sensors/bmg160.c
@@ -228,10 +228,11 @@ static void bmg160_read_measurement_data(FAR struct bmg160_dev_s *dev)
 
   /* Aquire the semaphore before the data is copied */
 
-  ret = sem_wait(&dev->datasem);
+  ret = nxsem_wait(&dev->datasem);
   if (ret < 0)
     {
       snerr("ERROR: Could not aquire dev->datasem: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
       return;
     }
 
@@ -457,12 +458,12 @@ static ssize_t bmg160_read(FAR struct file *filep, FAR char *buffer,
 
   /* Aquire the semaphore before the data is copied */
 
-  ret = sem_wait(&priv->datasem);
+  ret = nxsem_wait(&priv->datasem);
   if (ret < 0)
     {
-      int errcode = errno;
-      snerr("ERROR: Could not aquire priv->datasem: %d\n", errcode);
-      return -errcode;
+      snerr("ERROR: Could not aquire priv->datasem: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Copy the sensor data into the buffer */
diff --git a/drivers/sensors/hc_sr04.c b/drivers/sensors/hc_sr04.c
index 5ab7407afd..0a3dfa8e1a 100644
--- a/drivers/sensors/hc_sr04.c
+++ b/drivers/sensors/hc_sr04.c
@@ -154,11 +154,21 @@ static int hcsr04_open(FAR struct file *filep)
 {
   FAR struct inode *inode = filep->f_inode;
   FAR struct hcsr04_dev_s *priv = inode->i_private;
+  int ret;
 
-  while (sem_wait(&priv->devsem) != 0)
+  /* Get exclusive access */
+
+  do
     {
-      assert(errno == EINTR);
+      ret = nxsem_wait(&priv->devsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   nxsem_post(&priv->devsem);
   hcsr04_dbg("OPENED\n");
@@ -169,12 +179,21 @@ static int hcsr04_close(FAR struct file *filep)
 {
   FAR struct inode *inode = filep->f_inode;
   FAR struct hcsr04_dev_s *priv = inode->i_private;
-  int ret = OK;
+  int ret;
 
-  while (sem_wait(&priv->devsem) != 0)
+  /* Get exclusive access */
+
+  do
     {
-      assert(errno == EINTR);
+      ret = nxsem_wait(&priv->devsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   nxsem_post(&priv->devsem);
   hcsr04_dbg("CLOSED\n");
@@ -188,11 +207,21 @@ static ssize_t hcsr04_read(FAR struct file *filep, FAR char *buffer,
   FAR struct hcsr04_dev_s *priv = inode->i_private;
   int distance = 0;
   ssize_t length = 0;
+  int ret;
 
-  while (sem_wait(&priv->devsem) != 0)
+  /* Get exclusive access */
+
+  do
     {
-      assert(errno == EINTR);
+      ret = nxsem_wait(&priv->devsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   /* Setup and send a pulse to start measuring */
 
@@ -200,10 +229,19 @@ static ssize_t hcsr04_read(FAR struct file *filep, FAR char *buffer,
 
   /* Wait the convertion to finish */
 
-  while (sem_wait(&priv->conv_donesem) != 0)
+  /* Get exclusive access */
+
+  do
     {
-      assert(errno == EINTR);
+      ret = nxsem_wait(&priv->conv_donesem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   distance = hcsr04_read_distance(priv);
   if (distance < 0)
@@ -236,12 +274,21 @@ static int hcsr04_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 {
   FAR struct inode *inode = filep->f_inode;
   FAR struct hcsr04_dev_s *priv = inode->i_private;
-  int ret = OK;
+  int ret;
 
-  while (sem_wait(&priv->devsem) != 0)
+  /* Get exclusive access */
+
+  do
     {
-      assert(errno == EINTR);
+      ret = nxsem_wait(&priv->devsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   switch (cmd)
     {
@@ -307,9 +354,9 @@ static int hcsr04_poll(FAR struct file *filep, FAR struct pollfd *fds,
 {
   FAR struct inode *inode;
   FAR struct hcsr04_dev_s *priv;
-  int ret = OK;
-  int i;
   uint32_t flags;
+  int ret;
+  int i;
 
   DEBUGASSERT(filep && fds);
   inode = filep->f_inode;
@@ -317,10 +364,19 @@ static int hcsr04_poll(FAR struct file *filep, FAR struct pollfd *fds,
   DEBUGASSERT(inode && inode->i_private);
   priv = (FAR struct hcsr04_dev_s *)inode->i_private;
 
-  while (sem_wait(&priv->devsem) != 0)
+  /* Get exclusive access */
+
+  do
     {
-      assert(errno == EINTR);
+      ret = nxsem_wait(&priv->devsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   if (setup)
     {
diff --git a/drivers/sensors/hts221.c b/drivers/sensors/hts221.c
index cde8ef80d9..100bdc26fb 100644
--- a/drivers/sensors/hts221.c
+++ b/drivers/sensors/hts221.c
@@ -820,11 +820,21 @@ static int hts221_open(FAR struct file *filep)
 {
   FAR struct inode *inode = filep->f_inode;
   FAR struct hts221_dev_s *priv = inode->i_private;
+  int ret;
 
-  while (sem_wait(&priv->devsem) != 0)
+  /* Get exclusive access */
+
+  do
     {
-      assert(errno == EINTR);
+      ret = nxsem_wait(&priv->devsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   priv->config->set_power(priv->config, true);
   priv->config->irq_enable(priv->config, true);
@@ -838,12 +848,21 @@ static int hts221_close(FAR struct file *filep)
 {
   FAR struct inode *inode = filep->f_inode;
   FAR struct hts221_dev_s *priv = inode->i_private;
-  int ret = OK;
+  int ret;
 
-  while (sem_wait(&priv->devsem) != 0)
+  /* Get exclusive access */
+
+  do
     {
-      assert(errno == EINTR);
+      ret = nxsem_wait(&priv->devsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   priv->config->irq_enable(priv->config, false);
   ret = hts221_power_on_off(priv, false);
@@ -859,14 +878,23 @@ static ssize_t hts221_read(FAR struct file *filep, FAR char *buffer,
 {
   FAR struct inode *inode = filep->f_inode;
   FAR struct hts221_dev_s *priv = inode->i_private;
-  int ret = OK;
-  ssize_t length = 0;
   hts221_conv_data_t data;
+  ssize_t length = 0;
+  int ret;
 
-  while (sem_wait(&priv->devsem) != 0)
+  /* Get exclusive access */
+
+  do
     {
-      assert(errno == EINTR);
+      ret = nxsem_wait(&priv->devsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   ret = hts221_read_convert_data(priv, &data);
   if (ret < 0)
@@ -900,12 +928,21 @@ static int hts221_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 {
   FAR struct inode *inode = filep->f_inode;
   FAR struct hts221_dev_s *priv = inode->i_private;
-  int ret = OK;
+  int ret;
 
-  while (sem_wait(&priv->devsem) != 0)
+  /* Get exclusive access */
+
+  do
     {
-      assert(errno == EINTR);
+      ret = nxsem_wait(&priv->devsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   switch (cmd)
     {
@@ -996,9 +1033,9 @@ static int hts221_poll(FAR struct file *filep, FAR struct pollfd *fds,
 {
   FAR struct inode *inode;
   FAR struct hts221_dev_s *priv;
-  int ret = OK;
-  int i;
   uint32_t flags;
+  int ret;
+  int i;
 
   DEBUGASSERT(filep && fds);
   inode = filep->f_inode;
@@ -1006,10 +1043,19 @@ static int hts221_poll(FAR struct file *filep, FAR struct pollfd *fds,
   DEBUGASSERT(inode && inode->i_private);
   priv = (FAR struct hts221_dev_s *)inode->i_private;
 
-  while (sem_wait(&priv->devsem) != 0)
+  /* Get exclusive access */
+
+  do
     {
-      assert(errno == EINTR);
+      ret = nxsem_wait(&priv->devsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   if (setup)
     {
diff --git a/drivers/sensors/kxtj9.c b/drivers/sensors/kxtj9.c
index 9469b11ae1..8f08f04805 100644
--- a/drivers/sensors/kxtj9.c
+++ b/drivers/sensors/kxtj9.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/sensors/kxtj9.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * This driver derives from the Motorola Moto Z MDK:
@@ -344,9 +344,9 @@ static int kxtj9_configure(FAR struct kxtj9_dev_s *priv, uint8_t odr)
 
   do
     {
-      ret = sem_wait(&priv->exclsem);
+      ret = nxsem_wait(&priv->exclsem);
     }
-  while (ret < 0 && errno == EINTR);
+  while (ret == -EINTR);
 
   kxtj9_soft_reset(priv);
   kxtj9_set_mode_standby(priv);
@@ -397,9 +397,9 @@ static int kxtj9_enable(FAR struct kxtj9_dev_s *priv, bool on)
 
   do
     {
-      ret = sem_wait(&priv->exclsem);
+      ret = nxsem_wait(&priv->exclsem);
     }
-  while (ret < 0 && errno == EINTR);
+  while (ret == -EINTR);
 
   if (!on && priv->power_enabled)
     {
@@ -444,9 +444,9 @@ static int kxtj9_read_sensor_data(FAR struct kxtj9_dev_s *priv,
 
   do
     {
-      ret = sem_wait(&priv->exclsem);
+      ret = nxsem_wait(&priv->exclsem);
     }
-  while (ret < 0 && errno == EINTR);
+  while (ret == -EINTR);
 
   kxtj9_reg_read(priv, XOUT_L, (uint8_t *)acc_data, 6);
 
diff --git a/drivers/sensors/l3gd20.c b/drivers/sensors/l3gd20.c
index f681d63c1b..17755e6c7e 100644
--- a/drivers/sensors/l3gd20.c
+++ b/drivers/sensors/l3gd20.c
@@ -2,7 +2,7 @@
  * drivers/sensors/l3gd20.c
  * Character driver for the ST L3GD20 3-Axis gyroscope.
  *
- *   Copyright (C) Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2017 Gregory Nutt. All rights reserved.
  *   Author: Mateusz Szafoni <raiden00@railab.me>
  *
  * Based on drivers/sensors/lis3dsh.c
@@ -242,7 +242,7 @@ static void l3gd20_read_measurement_data(FAR struct l3gd20_dev_s *dev)
 
   /* Aquire the semaphore before the data is copied */
 
-  ret = sem_wait(&dev->datasem);
+  ret = nxsem_wait(&dev->datasem);
   if (ret < 0)
     {
       snerr("ERROR: Could not aquire dev->datasem: %d\n", ret);
@@ -507,12 +507,12 @@ static ssize_t l3gd20_read(FAR struct file *filep, FAR char *buffer,
 
   /* Acquire the semaphore before the data is copied */
 
-  ret = sem_wait(&priv->datasem);
+  ret = nxsem_wait(&priv->datasem);
   if (ret < 0)
     {
-      int errcode = errno;
-      snerr("ERROR: Could not aquire priv->datasem: %d\n", errcode);
-      return -errcode;
+      snerr("ERROR: Could not aquire priv->datasem: %d\n", ret);
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Copy the sensor data into the buffer */
diff --git a/drivers/sensors/lis2dh.c b/drivers/sensors/lis2dh.c
index d0020cac6c..0fe8f1cb89 100644
--- a/drivers/sensors/lis2dh.c
+++ b/drivers/sensors/lis2dh.c
@@ -275,14 +275,14 @@ static int lis2dh_close(FAR struct file *filep)
 static int lis2dh_fifo_start(FAR struct lis2dh_dev_s *priv)
 {
   uint8_t buf;
-  int err = OK;
+  int ret = OK;
 
   buf =  0x00 | priv->setup->trigger_selection |
       priv->setup->fifo_trigger_threshold;
   if (lis2dh_access(priv, ST_LIS2DH_FIFO_CTRL_REG, &buf, -1) != 1)
     {
       lis2dh_dbg("lis2dh: Failed to write FIFO control register\n");
-      err = -EIO;
+      ret = -EIO;
     }
   else
     {
@@ -291,7 +291,7 @@ static int lis2dh_fifo_start(FAR struct lis2dh_dev_s *priv)
       if (lis2dh_access(priv, ST_LIS2DH_FIFO_CTRL_REG, &buf, -1) != 1)
         {
           lis2dh_dbg("lis2dh: Failed to write FIFO control register\n");
-          err = -EIO;
+          ret = -EIO;
         }
       else
         {
@@ -301,7 +301,7 @@ static int lis2dh_fifo_start(FAR struct lis2dh_dev_s *priv)
         }
     }
 
-  return err;
+  return ret;
 }
 
 /****************************************************************************
@@ -323,7 +323,7 @@ static ssize_t lis2dh_read(FAR struct file *filep, FAR char *buffer,
   uint8_t int1_src = 0;
   uint8_t int2_src = 0;
   irqstate_t flags;
-  int err;
+  int ret;
 
   if (buflen <  sizeof(struct lis2dh_result) ||
       (buflen - sizeof(struct lis2dh_res_header)) % sizeof(struct lis2dh_vector_s) != 0)
@@ -332,10 +332,10 @@ static ssize_t lis2dh_read(FAR struct file *filep, FAR char *buffer,
       return -EINVAL;
     }
 
-  err = sem_wait(&priv->devsem);
-  if (err < 0)
+  ret = nxsem_wait(&priv->devsem);
+  if (ret < 0)
     {
-      return -EINTR;
+      return ret;
     }
 
   /* Do not allow read() if no SNIOC_WRITESETUP first. */
@@ -370,8 +370,8 @@ static ssize_t lis2dh_read(FAR struct file *filep, FAR char *buffer,
 
       if (readcount > 0)
         {
-          err = lis2dh_get_reading(priv, &ptr->measurements[0], true);
-          if (err < 0)
+          ret = lis2dh_get_reading(priv, &ptr->measurements[0], true);
+          if (ret < 0)
             {
               lis2dh_dbg("lis2dh: Failed to read xyz\n");
             }
@@ -440,7 +440,7 @@ static ssize_t lis2dh_read(FAR struct file *filep, FAR char *buffer,
             }
 
           ptr->header.meas_count +=
-              lis2dh_get_fifo_readings(priv, ptr, fifo_num_samples, &err);
+              lis2dh_get_fifo_readings(priv, ptr, fifo_num_samples, &ret);
         }
       while (!fifo_empty && ptr->header.meas_count < readcount);
 
@@ -468,7 +468,7 @@ static ssize_t lis2dh_read(FAR struct file *filep, FAR char *buffer,
            * further reading.
            */
 
-          err = lis2dh_fifo_start(priv);
+          ret = lis2dh_fifo_start(priv);
         }
     }
 
@@ -480,7 +480,7 @@ static ssize_t lis2dh_read(FAR struct file *filep, FAR char *buffer,
   if (lis2dh_access(priv, ST_LIS2DH_INT1_SRC_REG, &buf, 1) != 1)
     {
       lis2dh_dbg("lis2dh: Failed to read INT1_SRC_REG\n");
-      err = -EIO;
+      ret = -EIO;
     }
   if (buf & ST_LIS2DH_INT_SR_ACTIVE)
     {
@@ -502,7 +502,7 @@ static ssize_t lis2dh_read(FAR struct file *filep, FAR char *buffer,
   if (lis2dh_access(priv, ST_LIS2DH_INT2_SRC_REG, &buf, 1) != 1)
     {
       lis2dh_dbg("lis2dh: Failed to read INT2_SRC_REG\n");
-      err = -EIO;
+      ret = -EIO;
     }
   if (buf & ST_LIS2DH_INT_SR_ACTIVE)
     {
@@ -520,7 +520,7 @@ static ssize_t lis2dh_read(FAR struct file *filep, FAR char *buffer,
 
   nxsem_post(&priv->devsem);
 
-  /* 'err' was just for debugging, we do return partial reads here. */
+  /* 'ret' was just for debugging, we do return partial reads here. */
 
   return sizeof(ptr->header) +
       ptr->header.meas_count * sizeof(struct lis2dh_vector_s);
@@ -562,10 +562,10 @@ static int lis2dh_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
   DEBUGASSERT(inode && inode->i_private);
   priv = (FAR struct lis2dh_dev_s *)inode->i_private;
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
-      return -EINTR;
+      return ret;
     }
 
   switch (cmd)
@@ -680,7 +680,7 @@ static int lis2dh_poll(FAR struct file *filep, FAR struct pollfd *fds,
 {
   FAR struct inode *inode;
   FAR struct lis2dh_dev_s *priv;
-  int ret = OK;
+  int ret;
   int i;
 
   DEBUGASSERT(filep && fds);
@@ -689,10 +689,10 @@ static int lis2dh_poll(FAR struct file *filep, FAR struct pollfd *fds,
   DEBUGASSERT(inode && inode->i_private);
   priv = (FAR struct lis2dh_dev_s *)inode->i_private;
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
-      return -EINTR;
+      return ret;
     }
 
   if (setup)
diff --git a/drivers/sensors/lis3dsh.c b/drivers/sensors/lis3dsh.c
index 4cb8052ac4..aa94b1c3bf 100644
--- a/drivers/sensors/lis3dsh.c
+++ b/drivers/sensors/lis3dsh.c
@@ -231,7 +231,7 @@ static void lis3dsh_read_measurement_data(FAR struct lis3dsh_dev_s *dev)
 
   /* Aquire the semaphore before the data is copied */
 
-  ret = sem_wait(&dev->datasem);
+  ret = nxsem_wait(&dev->datasem);
   if (ret < 0)
     {
       snerr("ERROR: Could not aquire dev->datasem: %d\n", ret);
@@ -460,12 +460,11 @@ static ssize_t lis3dsh_read(FAR struct file *filep, FAR char *buffer,
 
   /* Aquire the semaphore before the data is copied */
 
-  ret = sem_wait(&priv->datasem);
+  ret = nxsem_wait(&priv->datasem);
   if (ret < 0)
     {
-      int errcode = errno;
-      snerr("ERROR: Could not aquire priv->datasem: %d\n", errcode);
-      return -errcode;
+      snerr("ERROR: Could not aquire priv->datasem: %d\n", ret);
+      return ret;
     }
 
   /* Copy the sensor data into the buffer */
diff --git a/drivers/sensors/lis3mdl.c b/drivers/sensors/lis3mdl.c
index 7cabd233e6..99d2b2b2d3 100644
--- a/drivers/sensors/lis3mdl.c
+++ b/drivers/sensors/lis3mdl.c
@@ -235,7 +235,7 @@ static void lis3mdl_read_measurement_data(FAR struct lis3mdl_dev_s *dev)
 
   /* Aquire the semaphore before the data is copied */
 
-  int ret = sem_wait(&dev->datasem);
+  int ret = nxsem_wait(&dev->datasem);
   if (ret != OK)
     {
       snerr("ERROR: Could not aquire dev->datasem: %d\n", ret);
@@ -497,12 +497,11 @@ static ssize_t lis3mdl_read(FAR struct file *filep, FAR char *buffer,
 
   /* Aquire the semaphore before the data is copied */
 
-  ret = sem_wait(&priv->datasem);
+  ret = nxsem_wait(&priv->datasem);
   if (ret < 0)
     {
-      int errcode = errno;
-      snerr("ERROR: Could not aquire priv->datasem: %d\n", errcode);
-      return -errcode;
+      snerr("ERROR: Could not aquire priv->datasem: %d\n", ret);
+      return ret;
     }
 
   /* Copy the sensor data into the buffer */
diff --git a/drivers/sensors/lps25h.c b/drivers/sensors/lps25h.c
index 5d419343c9..a173ae497d 100644
--- a/drivers/sensors/lps25h.c
+++ b/drivers/sensors/lps25h.c
@@ -342,10 +342,19 @@ static int lps25h_open(FAR struct file *filep)
   uint8_t addr = LPS25H_WHO_AM_I;
   int32_t ret;
 
-  while (sem_wait(&dev->devsem) != 0)
+  /* Get exclusive access */
+
+  do
     {
-      assert(errno == EINTR);
+      ret = nxsem_wait(&dev->devsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   dev->config->set_power(dev->config, true);
   ret = lps25h_read_reg8(dev, &addr, &value);
@@ -372,10 +381,19 @@ static int lps25h_close(FAR struct file *filep)
   FAR struct lps25h_dev_s *dev = inode->i_private;
   int ret;
 
-  while (sem_wait(&dev->devsem) != 0)
+  /* Get exclusive access */
+
+  do
     {
-      assert(errno == EINTR);
+      ret = nxsem_wait(&dev->devsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   dev->config->irq_enable(dev->config, false);
   dev->irqenabled = false;
@@ -392,14 +410,23 @@ static ssize_t lps25h_read(FAR struct file *filep, FAR char *buffer,
 {
   FAR struct inode *inode = filep->f_inode;
   FAR struct lps25h_dev_s *dev = inode->i_private;
-  int ret;
-  ssize_t length = 0;
   lps25h_pressure_data_t data;
+  ssize_t length = 0;
+  int ret;
 
-  while (sem_wait(&dev->devsem) != 0)
+  /* Get exclusive access */
+
+  do
     {
-      assert(errno == EINTR);
+      ret = nxsem_wait(&dev->devsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   ret = lps25h_configure_dev(dev);
   if (ret < 0)
@@ -716,12 +743,21 @@ static int lps25h_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 {
   FAR struct inode *inode = filep->f_inode;
   FAR struct lps25h_dev_s *dev = inode->i_private;
-  int ret = OK;
+  int ret;
 
-  while (sem_wait(&dev->devsem) != 0)
+  /* Get exclusive access */
+
+  do
     {
-      assert(errno == EINTR);
+      ret = nxsem_wait(&dev->devsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   switch (cmd)
     {
diff --git a/drivers/sensors/mlx90393.c b/drivers/sensors/mlx90393.c
index 74e89c540d..299fd84e10 100644
--- a/drivers/sensors/mlx90393.c
+++ b/drivers/sensors/mlx90393.c
@@ -216,7 +216,7 @@ static void mlx90393_read_measurement_data(FAR struct mlx90393_dev_s *dev)
 
   /* Aquire the semaphore before the data is copied */
 
-  ret = sem_wait(&dev->datasem);
+  ret = nxsem_wait(&dev->datasem);
   if (ret != OK)
     {
       snerr("ERROR: Could not aquire dev->datasem: %d\n", ret);
@@ -489,12 +489,11 @@ static ssize_t mlx90393_read(FAR struct file *filep, FAR char *buffer,
 
   /* Aquire the semaphore before the data is copied */
 
-  ret = sem_wait(&priv->datasem);
+  ret = nxsem_wait(&priv->datasem);
   if (ret < 0)
     {
-      int errcode = errno;
-      snerr("ERROR: Could not aquire priv->datasem: %d\n", errcode);
-      return -errcode;
+      snerr("ERROR: Could not aquire priv->datasem: %d\n", ret);
+      return ret;
     }
 
   data = (FAR struct mlx90393_sensor_data_s *)buffer;
diff --git a/drivers/sensors/qencoder.c b/drivers/sensors/qencoder.c
index 3cfb4e99db..be5879ac25 100644
--- a/drivers/sensors/qencoder.c
+++ b/drivers/sensors/qencoder.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/sensors/qencoder.c
  *
- *   Copyright (C) 2012-2013 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012-2013, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -128,10 +128,9 @@ static int qe_open(FAR struct file *filep)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&upper->exclsem);
+  ret = nxsem_wait(&upper->exclsem);
   if (ret < 0)
     {
-      ret = -errno;
       goto errout;
     }
 
@@ -197,10 +196,9 @@ static int qe_close(FAR struct file *filep)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&upper->exclsem);
+  ret = nxsem_wait(&upper->exclsem);
   if (ret < 0)
     {
-      ret = -errno;
       goto errout;
     }
 
@@ -288,7 +286,7 @@ static int qe_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&upper->exclsem);
+  ret = nxsem_wait(&upper->exclsem);
   if (ret < 0)
     {
       return ret;
diff --git a/drivers/sensors/xen1210.c b/drivers/sensors/xen1210.c
index ba672a36a8..0f3f84e198 100644
--- a/drivers/sensors/xen1210.c
+++ b/drivers/sensors/xen1210.c
@@ -173,14 +173,14 @@ static ssize_t xen1210_read(FAR struct file *filep, FAR char *buffer,
 
   /* Get exclusive access to the driver data structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
       snerr("Failed: Cannot get exclusive access to driver structure!\n");
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   sninfo("X = 0x%06X\n", priv->sample.data_x);
@@ -374,12 +374,11 @@ int xen1210_register(XEN1210_HANDLE handle, int minor)
 
   /* Get exclusive access to the device structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      int errval = errno;
-      snerr("ERROR: sem_wait failed: %d\n", errval);
-      return -errval;
+      snerr("ERROR: nxsem_wait failed: %d\n", ret);
+      return ret;
     }
 
   /* Register the character driver */
diff --git a/drivers/sensors/zerocross.c b/drivers/sensors/zerocross.c
index 3ed9b83c7e..6fcde36fb0 100644
--- a/drivers/sensors/zerocross.c
+++ b/drivers/sensors/zerocross.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/sensors/zerocross.c
  *
- *   Copyright (C) 2015 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -239,10 +239,10 @@ static int zc_open(FAR struct file *filep)
 
   /* Get exclusive access to the driver structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      snerr("ERROR: sem_wait failed: %d\n", ret);
+      snerr("ERROR: nxsem_wait failed: %d\n", ret);
       return ret;
     }
 
@@ -320,10 +320,10 @@ static int zc_close(FAR struct file *filep)
 
   /* Get exclusive access to the driver structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      snerr("ERROR: sem_wait failed: %d\n", ret);
+      snerr("ERROR: nxsem_wait failed: %d\n", ret);
       return ret;
     }
 
@@ -421,7 +421,7 @@ static int zc_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
       return ret;
diff --git a/drivers/serial/ptmx.c b/drivers/serial/ptmx.c
index 5bb85d1d5f..1ee1c08e3b 100644
--- a/drivers/serial/ptmx.c
+++ b/drivers/serial/ptmx.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/serial/ptmx.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -129,16 +129,21 @@ static struct ptmx_dev_s g_ptmx;
 
 static void ptmx_semtake(void)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&g_ptmx.px_exclsem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&g_ptmx.px_exclsem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      DEBUGASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 #define ptmx_semgive() nxsem_post(&g_ptmx.px_exclsem)
diff --git a/drivers/serial/pty.c b/drivers/serial/pty.c
index c9ffb06f88..a30e8935a7 100644
--- a/drivers/serial/pty.c
+++ b/drivers/serial/pty.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/serial/pty.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -210,10 +210,21 @@ static const struct file_operations g_pty_fops =
 
 static void pty_semtake(FAR struct pty_devpair_s *devpair)
 {
-  while (sem_wait(&devpair->pp_exclsem) < 0)
+  int ret;
+
+  do
     {
-      DEBUGASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&devpair->pp_exclsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
@@ -301,7 +312,7 @@ static int pty_open(FAR struct file *filep)
         {
           /* Wait until unlocked.  We will also most certainly suspend here. */
 
-          sem_wait(&devpair->pp_slavesem);
+          (void)nxsem_wait(&devpair->pp_slavesem);
 
           /* Get exclusive access to the device structure.  This might also
            * cause suspension.
diff --git a/drivers/serial/serial.c b/drivers/serial/serial.c
index 193b9fcb20..69ea5420a5 100644
--- a/drivers/serial/serial.c
+++ b/drivers/serial/serial.c
@@ -133,27 +133,34 @@ static const struct file_operations g_serialops =
 
 static int uart_takesem(FAR sem_t *sem, bool errout)
 {
-  /* Loop, ignoring interrupts, until we have successfully acquired the semaphore */
+  int ret;
 
-  while (sem_wait(sem) != OK)
+  do
     {
-      /* The only case that an error should occur here is if the wait was awakened
-       * by a signal.
-       */
+      /* Take the semaphore (perhaps waiting) */
 
-      ASSERT(get_errno() == EINTR);
-
-      /* When the signal is received, should we errout? Or should we just continue
-       * waiting until we have the semaphore?
-       */
-
-      if (errout)
+      ret = nxsem_wait(sem);
+      if (ret < 0)
         {
-          return -EINTR;
+          /* The only case that an error should occur here is if the wait was
+           * awakened by a signal.
+           */
+
+          DEBUGASSERT(ret == -EINTR);
+
+          /* When the signal is received, should we errout? Or should we just
+           * continue waiting until we have the semaphore?
+           */
+
+          if (errout)
+            {
+              return ret;
+            }
         }
     }
+  while (ret == -EINTR);
 
-  return OK;
+  return ret;
 }
 
 /************************************************************************************
diff --git a/drivers/spi/spi_bitbang.c b/drivers/spi/spi_bitbang.c
index 96538bbc26..8c650282bc 100644
--- a/drivers/spi/spi_bitbang.c
+++ b/drivers/spi/spi_bitbang.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/spi/spi_bitbang.c
  *
- *   Copyright (C) 2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -167,27 +167,32 @@ static const struct spi_ops_s g_spiops =
 static int spi_lock(FAR struct spi_dev_s *dev, bool lock)
 {
   FAR struct spi_bitbang_s *priv = (FAR struct spi_bitbang_s *)dev;
+  int ret;
 
   spiinfo("lock=%d\n", lock);
   if (lock)
     {
       /* Take the semaphore (perhaps waiting) */
 
-      while (sem_wait(&priv->exclsem) != 0)
+      do
         {
-          /* The only case that an error should occur here is if the wait was awakened
-           * by a signal.
+          ret = nxsem_wait(&priv->exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
   else
     {
       (void)nxsem_post(&priv->exclsem);
+      ret = OK;
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
diff --git a/drivers/spi/spi_driver.c b/drivers/spi/spi_driver.c
index a01665deda..9a1f19a4bb 100644
--- a/drivers/spi/spi_driver.c
+++ b/drivers/spi/spi_driver.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/spi/spi_driver.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -144,12 +144,11 @@ static int spidrvr_open(FAR struct file *filep)
 
   /* Get exclusive access to the SPI driver state structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      int errcode = errno;
-      DEBUGASSERT(errcode < 0);
-      return -errcode;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Increment the count of open references on the RTC driver */
@@ -183,12 +182,11 @@ static int spidrvr_close(FAR struct file *filep)
 
   /* Get exclusive access to the SPI driver state structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      int errcode = errno;
-      DEBUGASSERT(errcode < 0);
-      return -errcode;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Decrement the count of open references on the RTC driver */
@@ -255,12 +253,11 @@ static int spidrvr_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 
   /* Get exclusive access to the SPI driver state structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      int errcode = errno;
-      DEBUGASSERT(errcode < 0);
-      return -errcode;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Process the IOCTL command */
@@ -312,12 +309,11 @@ static int spidrvr_unlink(FAR struct inode *inode)
 
   /* Get exclusive access to the SPI driver state structure */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
   if (ret < 0)
     {
-      int errcode = errno;
-      DEBUGASSERT(errcode < 0);
-      return -errcode;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Are there open references to the driver data structure? */
diff --git a/drivers/syslog/ramlog.c b/drivers/syslog/ramlog.c
index 2c2c51f844..d1010a9f01 100644
--- a/drivers/syslog/ramlog.c
+++ b/drivers/syslog/ramlog.c
@@ -296,7 +296,7 @@ static ssize_t ramlog_read(FAR struct file *filep, FAR char *buffer, size_t len)
 
   /* Get exclusive access to the rl_tail index */
 
-  ret = sem_wait(&priv->rl_exclsem);
+  ret = nxsem_wait(&priv->rl_exclsem);
   if (ret < 0)
     {
       return ret;
@@ -352,7 +352,7 @@ static ssize_t ramlog_read(FAR struct file *filep, FAR char *buffer, size_t len)
            * but will be re-enabled while we are waiting.
            */
 
-          ret = sem_wait(&priv->rl_waitsem);
+          ret = nxsem_wait(&priv->rl_waitsem);
 
           /* Interrupts will be disabled when we return.  So the decrementing
            * rl_nwaiters here is safe.
@@ -367,7 +367,7 @@ static ssize_t ramlog_read(FAR struct file *filep, FAR char *buffer, size_t len)
             {
               /* Yes... then retake the mutual exclusion semaphore */
 
-              ret = sem_wait(&priv->rl_exclsem);
+              ret = nxsem_wait(&priv->rl_exclsem);
             }
 
           /* Was the semaphore wait successful? Did we successful re-take the
@@ -376,19 +376,16 @@ static ssize_t ramlog_read(FAR struct file *filep, FAR char *buffer, size_t len)
 
           if (ret < 0)
             {
-              /* No.. One of the two sem_wait's failed. */
-
-              int errval = errno;
-
+              /* No.. One of the two nxsem_wait's failed. */
               /* Were we awakened by a signal?  Did we read anything before
                * we received the signal?
                */
 
-              if (errval != EINTR || nread >= 0)
+              if (ret != -EINTR || nread >= 0)
                 {
                   /* Yes.. return the error. */
 
-                  nread = -errval;
+                  nread = ret;
                 }
 
               /* Break out to return what we have.  Note, we can't exactly
@@ -573,11 +570,10 @@ int ramlog_poll(FAR struct file *filep, FAR struct pollfd *fds, bool setup)
 
   /* Get exclusive access to the poll structures */
 
-  ret = sem_wait(&priv->rl_exclsem);
+  ret = nxsem_wait(&priv->rl_exclsem);
   if (ret < 0)
     {
-      int errval = errno;
-      return -errval;
+      return ret;
     }
 
   /* Are we setting up the poll?  Or tearing it down? */
diff --git a/drivers/syslog/syslog_device.c b/drivers/syslog/syslog_device.c
index b6ae867ec1..f4a135cf3c 100644
--- a/drivers/syslog/syslog_device.c
+++ b/drivers/syslog/syslog_device.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/syslog/syslog_device.c
  *
- *   Copyright (C) 2012, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -149,10 +149,10 @@ static inline int syslog_dev_takesem(void)
    * thread.  Wait for it to become available.
    */
 
-  ret = sem_wait(&g_syslog_dev.sl_sem);
+  ret = nxsem_wait(&g_syslog_dev.sl_sem);
   if (ret < 0)
     {
-      return -get_errno();
+      return ret;
     }
 
   /* We hold the semaphore.  We can safely mark ourself as the holder
diff --git a/drivers/timers/oneshot.c b/drivers/timers/oneshot.c
index df386e9a77..d7537e979e 100644
--- a/drivers/timers/oneshot.c
+++ b/drivers/timers/oneshot.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/timers/oneshot.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -233,7 +233,7 @@ static int oneshot_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&priv->od_exclsem);
+  ret = nxsem_wait(&priv->od_exclsem);
   if (ret < 0)
     {
       return ret;
diff --git a/drivers/timers/watchdog.c b/drivers/timers/watchdog.c
index 1936657605..06208e49dd 100644
--- a/drivers/timers/watchdog.c
+++ b/drivers/timers/watchdog.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/timers/watchdog.c
  *
- *   Copyright (C) 2012 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -126,10 +126,9 @@ static int wdog_open(FAR struct file *filep)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&upper->exclsem);
+  ret = nxsem_wait(&upper->exclsem);
   if (ret < 0)
     {
-      ret = -get_errno();
       goto errout;
     }
 
@@ -177,10 +176,9 @@ static int wdog_close(FAR struct file *filep)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&upper->exclsem);
+  ret = nxsem_wait(&upper->exclsem);
   if (ret < 0)
     {
-      ret = -get_errno();
       goto errout;
     }
 
@@ -252,7 +250,7 @@ static int wdog_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 
   /* Get exclusive access to the device structures */
 
-  ret = sem_wait(&upper->exclsem);
+  ret = nxsem_wait(&upper->exclsem);
   if (ret < 0)
     {
       return ret;
diff --git a/drivers/usbdev/usbmsc.c b/drivers/usbdev/usbmsc.c
index f79ad17e1e..2f645f0acb 100644
--- a/drivers/usbdev/usbmsc.c
+++ b/drivers/usbdev/usbmsc.c
@@ -1296,10 +1296,10 @@ static inline void usbmsc_sync_wait(FAR struct usbmsc_dev_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->thsynch);
-      DEBUGASSERT(ret == OK || errno == EINTR);
+      ret = nxsem_wait(&priv->thsynch);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/drivers/usbdev/usbmsc_scsi.c b/drivers/usbdev/usbmsc_scsi.c
index 2a7a8920df..8b20a008c4 100644
--- a/drivers/usbdev/usbmsc_scsi.c
+++ b/drivers/usbdev/usbmsc_scsi.c
@@ -1,7 +1,8 @@
 /****************************************************************************
  * drivers/usbdev/usbmsc_scsi.c
  *
- *   Copyright (C) 2008-2010, 2012, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2008-2010, 2012, 2016-2017 Gregory Nutt. All rights
+ *     reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Mass storage class device.  Bulk-only with SCSI subclass.
@@ -391,8 +392,8 @@ static void usbmsc_scsi_wait(FAR struct usbmsc_dev_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->thwaitsem);
-      DEBUGASSERT(ret == OK || errno == EINTR);
+      ret = nxsem_wait(&priv->thwaitsem);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
       UNUSED(ret); /* Eliminate warnings when debug is off */
     }
   while (priv->thwaiting);
@@ -2857,8 +2858,8 @@ void usbmsc_scsi_lock(FAR struct usbmsc_dev_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->thlock);
-      DEBUGASSERT(ret == OK || errno == EINTR);
+      ret = nxsem_wait(&priv->thlock);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 }
diff --git a/drivers/usbhost/usbhost_cdcacm.c b/drivers/usbhost/usbhost_cdcacm.c
index b1ad6cb314..250e561e23 100644
--- a/drivers/usbhost/usbhost_cdcacm.c
+++ b/drivers/usbhost/usbhost_cdcacm.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/usbhost/usbhost_cdcacm.c
  *
- *   Copyright (C) 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -472,16 +472,21 @@ static uint32_t g_devinuse;
 
 static void usbhost_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/drivers/usbhost/usbhost_devaddr.c b/drivers/usbhost/usbhost_devaddr.c
index 69f3a25284..9ca1d9a2f7 100644
--- a/drivers/usbhost/usbhost_devaddr.c
+++ b/drivers/usbhost/usbhost_devaddr.c
@@ -2,7 +2,7 @@
  * drivers/usbhost/usbhost_devaddr.c
  * Manage USB device addresses
  *
- *   Copyright (C) 2013, 2015 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013, 2015, 2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -67,16 +67,21 @@
 
 static void usbhost_takesem(FAR struct usbhost_devaddr_s *devgen)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&devgen->exclsem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&devgen->exclsem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 #define usbhost_givesem(devgen) nxsem_post(&devgen->exclsem)
diff --git a/drivers/usbhost/usbhost_hidkbd.c b/drivers/usbhost/usbhost_hidkbd.c
index 261590c5f7..eb329b75b1 100644
--- a/drivers/usbhost/usbhost_hidkbd.c
+++ b/drivers/usbhost/usbhost_hidkbd.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/usbhost/usbhost_hidkbd.c
  *
- *   Copyright (C) 2011-2013, 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011-2013, 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -599,16 +599,21 @@ static const uint8_t lcmap[USBHID_NUMSCANCODES] =
 
 static void usbhost_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/drivers/usbhost/usbhost_hidmouse.c b/drivers/usbhost/usbhost_hidmouse.c
index c51b11d88d..72ec7f52a1 100644
--- a/drivers/usbhost/usbhost_hidmouse.c
+++ b/drivers/usbhost/usbhost_hidmouse.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/usbhost/usbhost_hidmouse.c
  *
- *   Copyright (C) 2014, 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014, 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -459,16 +459,21 @@ static struct usbhost_state_s *g_priv;    /* Data passed to thread */
 
 static void usbhost_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
@@ -1377,7 +1382,7 @@ static int usbhost_waitsample(FAR struct usbhost_state_s *priv,
 
       iinfo("Waiting..\n");
       priv->nwaiters++;
-      ret = sem_wait(&priv->waitsem);
+      ret = nxsem_wait(&priv->waitsem);
       priv->nwaiters--;
 
       if (ret < 0)
@@ -1386,9 +1391,8 @@ static int usbhost_waitsample(FAR struct usbhost_state_s *priv,
            * the failure now.
            */
 
-          ierr("ERROR: sem_wait: %d\n", errno);
-          DEBUGASSERT(errno == EINTR);
-          ret = -EINTR;
+          ierr("ERROR: nxsem_wait: %d\n", ret);
+          DEBUGASSERT(ret == -EINTR);
           goto errout;
         }
 
@@ -1408,7 +1412,7 @@ static int usbhost_waitsample(FAR struct usbhost_state_s *priv,
    * Interrupts and pre-emption will be re-enabled while we wait.
    */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
 
 errout:
   /* Then re-enable interrupts.  We might get interrupt here and there
diff --git a/drivers/usbhost/usbhost_skeleton.c b/drivers/usbhost/usbhost_skeleton.c
index c815022024..651f99fb52 100644
--- a/drivers/usbhost/usbhost_skeleton.c
+++ b/drivers/usbhost/usbhost_skeleton.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/usbhost/usbhost_skeleton.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -214,16 +214,21 @@ static uint32_t g_devinuse;
 
 static void usbhost_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/drivers/usbhost/usbhost_storage.c b/drivers/usbhost/usbhost_storage.c
index c61974ff72..71f8c951b1 100644
--- a/drivers/usbhost/usbhost_storage.c
+++ b/drivers/usbhost/usbhost_storage.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/usbhost/usbhost_storage.c
  *
- *   Copyright (C) 2010-2013, 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2010-2013, 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -328,16 +328,21 @@ static uint32_t g_devinuse;
 
 static void usbhost_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      ASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/drivers/usbhost/usbhost_xboxcontroller.c b/drivers/usbhost/usbhost_xboxcontroller.c
index ee01e53136..01e1ec808e 100644
--- a/drivers/usbhost/usbhost_xboxcontroller.c
+++ b/drivers/usbhost/usbhost_xboxcontroller.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/usbhost/usbhost_xboxcontroller.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *            Brian Webb <webbbn@gmail.com>
  *
@@ -336,16 +336,21 @@ static struct usbhost_state_s *g_priv;    /* Data passed to thread */
 
 static void usbhost_takesem(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      DEBUGASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
@@ -989,7 +994,7 @@ static int usbhost_waitsample(FAR struct usbhost_state_s *priv,
 
       iinfo("Waiting..\n");
       priv->nwaiters++;
-      ret = sem_wait(&priv->waitsem);
+      ret = nxsem_wait(&priv->waitsem);
       priv->nwaiters--;
 
       if (ret < 0)
@@ -998,9 +1003,8 @@ static int usbhost_waitsample(FAR struct usbhost_state_s *priv,
            * the failure now.
            */
 
-          ierr("ERROR: sem_wait: %d\n", errno);
-          DEBUGASSERT(errno == EINTR);
-          ret = -EINTR;
+          ierr("ERROR: nxsem_wait: %d\n", ret);
+          DEBUGASSERT(ret == -EINTR);
           goto errout;
         }
 
@@ -1020,7 +1024,7 @@ static int usbhost_waitsample(FAR struct usbhost_state_s *priv,
    * Interrupts and pre-emption will be re-enabled while we wait.
    */
 
-  ret = sem_wait(&priv->exclsem);
+  ret = nxsem_wait(&priv->exclsem);
 
 errout:
   /* Then re-enable interrupts.  We might get interrupt here and there
diff --git a/drivers/usbmisc/fusb301.c b/drivers/usbmisc/fusb301.c
index c1f121a1c2..98da77b596 100644
--- a/drivers/usbmisc/fusb301.c
+++ b/drivers/usbmisc/fusb301.c
@@ -550,10 +550,10 @@ static ssize_t fusb301_read(FAR struct file *filep, FAR char *buffer, size_t buf
 
   ptr = (struct fusb301_result_s *)buffer;
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
-      return -EINTR;
+      return ret;
     }
 
   flags = enter_critical_section();
@@ -596,10 +596,10 @@ static int fusb301_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
   FAR struct fusb301_dev_s *priv = inode->i_private;
   int ret;
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
-      return -EINTR;
+      return ret;
     }
 
   fusb301_info("cmd: 0x%02X, arg:%lu\n", cmd, arg);
@@ -681,10 +681,10 @@ static int fusb301_poll(FAR struct file *filep, FAR struct pollfd *fds, bool set
   DEBUGASSERT(inode && inode->i_private);
   priv = (FAR struct fusb301_dev_s *)inode->i_private;
 
-  ret = sem_wait(&priv->devsem);
+  ret = nxsem_wait(&priv->devsem);
   if (ret < 0)
     {
-      return -EINTR;
+      return ret;
     }
 
   if (setup)
diff --git a/drivers/wireless/cc3000/cc3000.c b/drivers/wireless/cc3000/cc3000.c
index 1aa0b2ca40..162d8b5794 100644
--- a/drivers/wireless/cc3000/cc3000.c
+++ b/drivers/wireless/cc3000/cc3000.c
@@ -213,16 +213,21 @@ uint8_t spi_readCommand[] = READ_COMMAND;
 
 static inline void cc3000_devtake(FAR struct cc3000_dev_s *priv)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&priv->devsem) < 0)
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->devsem);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      DEBUGASSERT(errno == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static inline void cc3000_devgive(FAR struct cc3000_dev_s *priv)
@@ -349,10 +354,10 @@ static int cc3000_wait(FAR struct cc3000_dev_s *priv, sem_t *psem)
 
   /* Wait on first psem to become signaled */
 
-  ret = sem_wait(psem);
+  ret = nxsem_wait(psem);
   if (ret < 0)
     {
-      return -errno;
+      return ret;
     }
 
   /* Then retake the mutual exclusion semaphore */
@@ -478,7 +483,7 @@ static void *select_thread_func(FAR void *arg)
 
   while (1)
     {
-      sem_wait(&priv->selectsem);
+      nxsem_wait(&priv->selectsem);
 
       CHECK_GUARD(priv);
 
@@ -710,7 +715,7 @@ static void *cc3000_worker(FAR void *arg)
                     cc3000_devgive(priv);
 
                     ninfo("Wait On Completion\n");
-                    sem_wait(priv->wrkwaitsem);
+                    nxsem_wait(priv->wrkwaitsem);
                     ninfo("Completed S:%d irq :%d\n",
                           priv->state, priv->config->irq_read(priv->config));
 
@@ -1118,7 +1123,7 @@ static ssize_t cc3000_read(FAR struct file *filep, FAR char *buffer, size_t len)
        */
 
       ninfo("Waiting..\n");
-      ret = sem_wait(&priv->waitsem);
+      ret = nxsem_wait(&priv->waitsem);
       priv->nwaiters--;
       sched_unlock();
 
@@ -1137,19 +1142,17 @@ static ssize_t cc3000_read(FAR struct file *filep, FAR char *buffer, size_t len)
 
       if (ret < 0)
         {
-          /* No.. One of the two sem_wait's failed. */
-
-          int errval = errno;
+          /* No.. One of the two nxsem_wait's failed. */
 
           /* Were we awakened by a signal?  Did we read anything before
            * we received the signal?
            */
 
-          if (errval != EINTR || nread  >= 0)
+          if (ret != -EINTR || nread  >= 0)
             {
               /* Yes.. return the error. */
 
-              nread = -errval;
+              nread = ret;
             }
 
           /* Break out to return what we have.  Note, we can't exactly
@@ -1279,8 +1282,8 @@ static ssize_t cc3000_write(FAR struct file *filep, FAR const char *usrbuffer, s
           /* This should only happen if the wait was canceled by an signal */
 
           cc3000_deselect_and_unlock(priv->spi);
-          ninfo("sem_wait: %d\n", errno);
-          DEBUGASSERT(errno == EINTR);
+          ninfo("nxsem_wait: %d\n", ret);
+          DEBUGASSERT(ret == -EINTR);
           nwritten = ret;
           goto errout_without_sem;
         }
@@ -1642,9 +1645,9 @@ static int cc3000_wait_data(FAR struct cc3000_dev_s *priv, int sockfd)
         {
           sched_lock();
           cc3000_devgive(priv);
-          nxsem_post(&priv->selectsem);         /* Wake select thread if need be */
-          sem_wait(&priv->sockets[s].semwait);  /* Wait caller on select to finish */
-          sem_wait(&priv->selectsem);           /* Sleep select thread */
+          nxsem_post(&priv->selectsem);          /* Wake select thread if need be */
+          nxsem_wait(&priv->sockets[s].semwait); /* Wait caller on select to finish */
+          nxsem_wait(&priv->selectsem);          /* Sleep select thread */
           cc3000_devtake(priv);
           sched_unlock();
 
@@ -1690,9 +1693,9 @@ static int cc3000_accept_socket(FAR struct cc3000_dev_s *priv, int sd, struct so
 
   sched_lock();
   cc3000_devgive(priv);
-  nxsem_post(&priv->selectsem);                  /* Wake select thread if need be */
-  sem_wait(&priv->accepting_socket.acc.semwait); /* Wait caller on select to finish */
-  sem_wait(&priv->selectsem);                    /* Sleep the Thread */
+  nxsem_post(&priv->selectsem);                    /* Wake select thread if need be */
+  nxsem_wait(&priv->accepting_socket.acc.semwait); /* Wait caller on select to finish */
+  nxsem_wait(&priv->selectsem);                    /* Sleep the Thread */
   cc3000_devtake(priv);
   sched_unlock();
 
@@ -1800,8 +1803,8 @@ static int cc3000_remove_socket(FAR struct cc3000_dev_s *priv, int sd)
       sched_lock();
       cc3000_devgive(priv);
       nxsem_post(&priv->selectsem);  /* Wake select thread if need be */
-      sem_wait(ps);
-      sem_wait(&priv->selectsem);    /* Sleep the Thread */
+      nxsem_wait(ps);
+      nxsem_wait(&priv->selectsem);  /* Sleep the Thread */
       cc3000_devtake(priv);
       sched_unlock();
     }
diff --git a/drivers/wireless/cc3000/cc3000drv.c b/drivers/wireless/cc3000/cc3000drv.c
index 8956ff014e..d5fd7384db 100644
--- a/drivers/wireless/cc3000/cc3000drv.c
+++ b/drivers/wireless/cc3000/cc3000drv.c
@@ -231,6 +231,7 @@ static void *unsoliced_thread_func(void *parameter)
 void cc3000_open(gcSpiHandleRx pfRxHandler)
 {
   int status;
+  int ret;
   int fd;
 
   DEBUGASSERT(spiconf.cc3000fd == -1);
@@ -257,10 +258,17 @@ void cc3000_open(gcSpiHandleRx pfRxHandler)
 
       /* Wait unsoliced_thread to wake-up. */
 
-      while (sem_wait(&spiconf.unsoliced_thread_wakesem) != 0)
+      do
         {
-          ASSERT(errno == EINTR);
+          ret = nxsem_wait(&spiconf.unsoliced_thread_wakesem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
+           */
+
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
    }
 
   DEBUGASSERT(spiconf.cc3000fd >= 0);
diff --git a/drivers/wireless/ieee80211/bcmf_cdc.c b/drivers/wireless/ieee80211/bcmf_cdc.c
index 3b775487f9..7c540cdc82 100644
--- a/drivers/wireless/ieee80211/bcmf_cdc.c
+++ b/drivers/wireless/ieee80211/bcmf_cdc.c
@@ -178,10 +178,10 @@ int bcmf_cdc_control_request(FAR struct bcmf_dev_s *priv,
 
   /* Take device control mutex */
 
-  if ((ret = sem_wait(&priv->control_mutex)) != OK)
-   {
+  if ((ret = nxsem_wait(&priv->control_mutex)) < 0)
+    {
       return ret;
-   }
+    }
 
   ret = bcmf_cdc_control_request_unsafe(priv, ifidx, set, cmd,
                                         name, data, len);
diff --git a/drivers/wireless/ieee80211/bcmf_driver.c b/drivers/wireless/ieee80211/bcmf_driver.c
index c388651afd..02465428dc 100644
--- a/drivers/wireless/ieee80211/bcmf_driver.c
+++ b/drivers/wireless/ieee80211/bcmf_driver.c
@@ -851,7 +851,7 @@ int bcmf_wl_start_scan(FAR struct bcmf_dev_s *priv, struct iwreq *iwr)
 
   /* Lock control_mutex semaphore */
 
-  if ((ret = sem_wait(&priv->control_mutex)) != OK)
+  if ((ret = nxsem_wait(&priv->control_mutex)) < 0)
     {
        goto exit_failed;
     }
@@ -894,6 +894,7 @@ int bcmf_wl_start_scan(FAR struct bcmf_dev_s *priv, struct iwreq *iwr)
 exit_sem_post:
   priv->scan_status = BCMF_SCAN_DISABLED;
   nxsem_post(&priv->control_mutex);
+
 exit_failed:
   wlinfo("Failed\n");
   return ret;
@@ -917,11 +918,10 @@ int bcmf_wl_get_scan_results(FAR struct bcmf_dev_s *priv, struct iwreq *iwr)
 
   /* Lock control_mutex semaphore to avoid race condition */
 
-  if ((ret = sem_wait(&priv->control_mutex)) != OK)
-   {
-      ret = -EIO;
+  if ((ret = nxsem_wait(&priv->control_mutex)) < 0)
+    {
       goto exit_failed;
-   }
+    }
 
   if (!priv->scan_result)
     {
@@ -970,10 +970,11 @@ exit_sem_post:
   nxsem_post(&priv->control_mutex);
 
 exit_failed:
-  if (ret)
+  if (ret < 0)
     {
       iwr->u.data.length = 0;
     }
+
   return ret;
 }
 
diff --git a/drivers/wireless/ieee80211/bcmf_sdio.c b/drivers/wireless/ieee80211/bcmf_sdio.c
index bfb911c6c0..2742b85bfe 100644
--- a/drivers/wireless/ieee80211/bcmf_sdio.c
+++ b/drivers/wireless/ieee80211/bcmf_sdio.c
@@ -737,9 +737,9 @@ void bcmf_sdio_waitdog_timeout(int argc, wdparm_t arg1, ...)
 
 int bcmf_sdio_thread(int argc, char **argv)
 {
-  int ret;
   FAR struct bcmf_dev_s *priv = g_sdio_priv;
   FAR struct bcmf_sdio_dev_s *sbus = (FAR struct bcmf_sdio_dev_s *)priv->bus;
+  int ret;
 
   wlinfo("Enter\n");
 
@@ -751,8 +751,8 @@ int bcmf_sdio_thread(int argc, char **argv)
     {
       /* Wait for event (device interrupt, user request or waitdog timer) */
 
-      ret = sem_wait(&sbus->thread_signal);
-      if (ret != OK)
+      ret = nxsem_wait(&sbus->thread_signal);
+      if (ret < 0)
         {
           wlerr("Error while waiting for semaphore\n");
           break;
@@ -818,6 +818,7 @@ int bcmf_sdio_thread(int argc, char **argv)
       if (sbus->intstatus & I_HMB_FRAME_IND)
         {
           /* Try again */
+
           wlinfo("Try read again\n");
           continue;
         }
@@ -842,7 +843,7 @@ struct bcmf_sdio_frame *bcmf_sdio_allocate_frame(FAR struct bcmf_dev_s *priv,
 
   while (1)
     {
-      if (sem_wait(&sbus->queue_mutex))
+      if (nxsem_wait(&sbus->queue_mutex < 0))
         {
           PANIC();
         }
@@ -889,7 +890,7 @@ void bcmf_sdio_free_frame(FAR struct bcmf_dev_s *priv,
   // wlinfo("free %p\n", sframe);
   FAR struct bcmf_sdio_dev_s *sbus = (FAR struct bcmf_sdio_dev_s *)priv->bus;
 
-  if (sem_wait(&sbus->queue_mutex))
+  if (nxsem_wait(&sbus->queue_mutex) < 0)
     {
       PANIC();
     }
diff --git a/drivers/wireless/ieee80211/bcmf_sdpcm.c b/drivers/wireless/ieee80211/bcmf_sdpcm.c
index e86da4c38b..fd7fd9717a 100644
--- a/drivers/wireless/ieee80211/bcmf_sdpcm.c
+++ b/drivers/wireless/ieee80211/bcmf_sdpcm.c
@@ -253,10 +253,11 @@ int bcmf_sdpcm_readframe(FAR struct bcmf_dev_s *priv)
 
         /* Queue frame and notify network layer frame is available */
 
-        if (sem_wait(&sbus->queue_mutex))
+        if (nxsem_wait(&sbus->queue_mutex) < 0)
           {
             PANIC();
           }
+
         bcmf_dqueue_push(&sbus->rx_queue, &sframe->list_entry);
         nxsem_post(&sbus->queue_mutex);
 
@@ -306,7 +307,7 @@ int bcmf_sdpcm_sendframe(FAR struct bcmf_dev_s *priv)
     }
 
 
-  if (sem_wait(&sbus->queue_mutex))
+  if (nxsem_wait(&sbus->queue_mutex) < 0)
     {
       PANIC();
     }
@@ -383,7 +384,7 @@ int bcmf_sdpcm_queue_frame(FAR struct bcmf_dev_s *priv,
 
   /* Add frame in tx queue */
 
-  if (sem_wait(&sbus->queue_mutex))
+  if (nxsem_wait(&sbus->queue_mutex) < 0)
     {
       PANIC();
     }
@@ -445,7 +446,7 @@ struct bcmf_frame_s *bcmf_sdpcm_get_rx_frame(FAR struct bcmf_dev_s *priv)
   struct bcmf_sdio_frame *sframe;
   FAR struct bcmf_sdio_dev_s *sbus = (FAR struct bcmf_sdio_dev_s *)priv->bus;
 
-  if (sem_wait(&sbus->queue_mutex))
+  if (nxsem_wait(&sbus->queue_mutex) < 0)
     {
       PANIC();
     }
diff --git a/drivers/wireless/ieee802154/at86rf23x/at86rf23x.c b/drivers/wireless/ieee802154/at86rf23x/at86rf23x.c
index 56f3c6b54a..ba6486d8b4 100644
--- a/drivers/wireless/ieee802154/at86rf23x/at86rf23x.c
+++ b/drivers/wireless/ieee802154/at86rf23x/at86rf23x.c
@@ -1450,7 +1450,7 @@ static int at86rf23x_transmit(FAR struct ieee802154_radio_s *ieee,
 
   /* Put the thread that requested transfer to a waiting state */
 
-  sem_wait(&dev->ieee.txsem);
+  nxsem_wait(&dev->ieee.txsem);
 
   /* TODO Verify that I want to stay in the PLL state or if I want to roll
    * back to RX_ON.
diff --git a/drivers/wireless/ieee802154/mrf24j40/mrf24j40.c b/drivers/wireless/ieee802154/mrf24j40/mrf24j40.c
index d14d1f83bb..48d194f021 100644
--- a/drivers/wireless/ieee802154/mrf24j40/mrf24j40.c
+++ b/drivers/wireless/ieee802154/mrf24j40/mrf24j40.c
@@ -166,7 +166,9 @@ void mrf24j40_dopoll_csma(FAR void *arg)
 
   /* Get exclusive access to the driver */
 
-  while (sem_wait(&dev->exclsem) != 0) { }
+  while (nxsem_wait(&dev->exclsem) < 0)
+    {
+    }
 
   /* If this a CSMA transaction and we have room in the CSMA fifo */
 
@@ -223,7 +225,9 @@ void mrf24j40_dopoll_gts(FAR void *arg)
 
   /* Get exclusive access to the driver */
 
-  while (sem_wait(&dev->exclsem) != 0) { }
+  while (nxsem_wait(&dev->exclsem) < 0)
+    {
+    }
 
   for (gts = 0; gts < MRF24J40_GTS_SLOTS; gts++)
     {
diff --git a/drivers/wireless/ieee802154/mrf24j40/mrf24j40_interrupt.c b/drivers/wireless/ieee802154/mrf24j40/mrf24j40_interrupt.c
index 82b85475ad..6bb1f226fd 100644
--- a/drivers/wireless/ieee802154/mrf24j40/mrf24j40_interrupt.c
+++ b/drivers/wireless/ieee802154/mrf24j40/mrf24j40_interrupt.c
@@ -150,7 +150,9 @@ static void mrf24j40_irqwork_txnorm(FAR struct mrf24j40_radio_s *dev)
 
       nxsem_post(&dev->exclsem);
       mrf24j40_dopoll_csma(dev);
-      while (sem_wait(&dev->exclsem) != 0) { }
+      while (nxsem_wait(&dev->exclsem) < 0)
+        {
+        }
     }
 }
 
@@ -310,7 +312,9 @@ void mrf24j40_irqworker(FAR void *arg)
 
   /* Get exclusive access to the driver */
 
-  while (sem_wait(&dev->exclsem) != 0) { }
+  while (nxsem_wait(&dev->exclsem) < 0)
+    {
+    }
 
   /* Read and store INTSTAT - this clears the register. */
 
diff --git a/drivers/wireless/ieee802154/mrf24j40/mrf24j40_radif.c b/drivers/wireless/ieee802154/mrf24j40/mrf24j40_radif.c
index 86b9d2b91d..08e16540a6 100644
--- a/drivers/wireless/ieee802154/mrf24j40/mrf24j40_radif.c
+++ b/drivers/wireless/ieee802154/mrf24j40/mrf24j40_radif.c
@@ -310,12 +310,14 @@ int mrf24j40_txdelayed(FAR struct ieee802154_radio_s *radio,
 {
   FAR struct mrf24j40_radio_s *dev = (FAR struct mrf24j40_radio_s *)radio;
   uint8_t reg;
+  int ret;
 
   /* Get exclusive access to the radio device */
 
-  if (sem_wait(&dev->exclsem) != 0)
+  ret = nxsem_wait(&dev->exclsem);
+  if (ret < 0)
     {
-      return -EINTR;
+      return ret;
     }
 
   /* There should never be more than one of these transactions at once. */
@@ -344,9 +346,10 @@ int mrf24j40_txdelayed(FAR struct ieee802154_radio_s *radio,
 
       /* Get exclusive access to the radio device */
 
-      if (sem_wait(&dev->exclsem) != 0)
+      ret = nxsem_wait(&dev->exclsem);
+      if (ret < 0)
         {
-          return -EINTR;
+          return ret;
         }
     }
 
diff --git a/drivers/wireless/ieee802154/xbee/xbee.c b/drivers/wireless/ieee802154/xbee/xbee.c
index 44eab214e6..6881f636b0 100644
--- a/drivers/wireless/ieee802154/xbee/xbee.c
+++ b/drivers/wireless/ieee802154/xbee/xbee.c
@@ -1141,7 +1141,7 @@ void xbee_query_firmwareversion(FAR struct xbee_priv_s *priv)
   xbee_register_respwaiter(priv, &respwaiter);
   xbee_at_query(priv, "VR");
 
-  sem_wait(&respwaiter.sem);
+  nxsem_wait(&respwaiter.sem);
 
   xbee_unregister_respwaiter(priv, &respwaiter);
 
@@ -1168,7 +1168,7 @@ void xbee_query_panid(FAR struct xbee_priv_s *priv)
   xbee_register_respwaiter(priv, &respwaiter);
   xbee_at_query(priv, "ID");
 
-  sem_wait(&respwaiter.sem);
+  nxsem_wait(&respwaiter.sem);
 
   xbee_unregister_respwaiter(priv, &respwaiter);
 
@@ -1195,12 +1195,12 @@ void xbee_query_eaddr(FAR struct xbee_priv_s *priv)
   xbee_register_respwaiter(priv, &respwaiter);
   xbee_at_query(priv, "SH");
 
-  sem_wait(&respwaiter.sem);
+  nxsem_wait(&respwaiter.sem);
 
   respwaiter.resp_id = XBEE_RESP_AT_SERIALLOW;
   xbee_at_query(priv, "SL");
 
-  sem_wait(&respwaiter.sem);
+  nxsem_wait(&respwaiter.sem);
 
   xbee_unregister_respwaiter(priv, &respwaiter);
   nxsem_destroy(&respwaiter.sem);
@@ -1226,7 +1226,7 @@ void xbee_query_saddr(FAR struct xbee_priv_s *priv)
   xbee_register_respwaiter(priv, &respwaiter);
   xbee_at_query(priv, "MY");
 
-  sem_wait(&respwaiter.sem);
+  nxsem_wait(&respwaiter.sem);
 
   xbee_unregister_respwaiter(priv, &respwaiter);
 
@@ -1253,7 +1253,7 @@ void xbee_query_chan(FAR struct xbee_priv_s *priv)
   xbee_register_respwaiter(priv, &respwaiter);
   xbee_at_query(priv, "CH");
 
-  sem_wait(&respwaiter.sem);
+  nxsem_wait(&respwaiter.sem);
 
   xbee_unregister_respwaiter(priv, &respwaiter);
 
diff --git a/drivers/wireless/ieee802154/xbee/xbee.h b/drivers/wireless/ieee802154/xbee/xbee.h
index e8fee0fda0..92c7385147 100644
--- a/drivers/wireless/ieee802154/xbee/xbee.h
+++ b/drivers/wireless/ieee802154/xbee/xbee.h
@@ -244,22 +244,22 @@ static inline int xbee_takesem(sem_t *sem, bool allowinterrupt)
     {
       /* Take a count from the semaphore, possibly waiting */
 
-      ret = sem_wait(sem);
+      ret = nxsem_wait(sem);
       if (ret < 0)
         {
           /* EINTR is the only error that we expect */
 
-          DEBUGASSERT(get_errno() == EINTR);
+          DEBUGASSERT(ret == -EINTR);
 
           if (allowinterrupt)
             {
-              return -EINTR;
+              return ret;
             }
         }
     }
-  while (ret != OK);
+  while (ret == -EINTR);
 
-  return OK;
+  return ret;
 }
 
 #ifdef CONFIG_XBEE_LOCK_VERBOSE
diff --git a/drivers/wireless/ieee802154/xbee/xbee_netdev.c b/drivers/wireless/ieee802154/xbee/xbee_netdev.c
index 96e694f559..ba17982311 100644
--- a/drivers/wireless/ieee802154/xbee/xbee_netdev.c
+++ b/drivers/wireless/ieee802154/xbee/xbee_netdev.c
@@ -466,7 +466,7 @@ static void xbeenet_notify(FAR struct xbee_maccb_s *maccb,
   /* Get exclusive access to the driver structure.  We don't care about any
    * signals so if we see one, just go back to trying to get access again */
 
-  while (sem_wait(&priv->xd_exclsem) < 0);
+  while (nxsem_wait(&priv->xd_exclsem) < 0);
 
   /* If there is a registered notification receiver, queue the event and signal
    * the receiver. Events should be popped from the queue from the application
@@ -1089,10 +1089,10 @@ static int xbeenet_ioctl(FAR struct net_driver_s *dev, int cmd,
   FAR struct xbeenet_driver_s *priv = (FAR struct xbeenet_driver_s *)dev->d_private;
   int ret = -EINVAL;
 
-  ret = sem_wait(&priv->xd_exclsem);
+  ret = nxsem_wait(&priv->xd_exclsem);
   if (ret < 0)
     {
-      wlerr("ERROR: sem_wait failed: %d\n", ret);
+      wlerr("ERROR: nxsem_wait failed: %d\n", ret);
       return ret;
     }
 
@@ -1168,21 +1168,22 @@ static int xbeenet_ioctl(FAR struct net_driver_s *dev, int cmd,
 
                       /* Wait to be signaled when an event is queued */
 
-                      if (sem_wait(&priv->xd_eventsem) < 0)
+                      ret = nxsem_wait(&priv->xd_eventsem);
+                      if (ret < 0)
                         {
-                          DEBUGASSERT(errno == EINTR);
+                          DEBUGASSERT(ret == -EINTR);
                           priv->xd_eventpending = false;
-                          return -EINTR;
+                          return ret;
                         }
 
                       /* Get exclusive access again, then loop back around and try and
                        * pop an event off the queue
                        */
 
-                      ret = sem_wait(&priv->xd_exclsem);
+                      ret = nxsem_wait(&priv->xd_exclsem);
                       if (ret < 0)
                         {
-                          wlerr("ERROR: sem_wait failed: %d\n", ret);
+                          wlerr("ERROR: nxsem_wait failed: %d\n", ret);
                           return ret;
                         }
                     }
diff --git a/drivers/wireless/nrf24l01.c b/drivers/wireless/nrf24l01.c
index 251bea64e6..a9d435ebce 100644
--- a/drivers/wireless/nrf24l01.c
+++ b/drivers/wireless/nrf24l01.c
@@ -510,7 +510,7 @@ static uint8_t nrf24l01_setregbit(FAR struct nrf24l01_dev_s *dev,
 static void fifoput(FAR struct nrf24l01_dev_s *dev, uint8_t pipeno,
                     FAR uint8_t *buffer, uint8_t buflen)
 {
-  sem_wait(&dev->sem_fifo);
+  (void)nxsem_wait(&dev->sem_fifo);
   while (dev->fifo_len + buflen + 1 > CONFIG_WL_NRF24L01_RXFIFO_LEN)
     {
       /* TODO: Set fifo overrun flag ! */
@@ -546,7 +546,7 @@ static uint8_t fifoget(FAR struct nrf24l01_dev_s *dev, FAR uint8_t *buffer,
   uint8_t pktlen;
   uint8_t i;
 
-  sem_wait(&dev->sem_fifo);
+  (void)nxsem_wait(&dev->sem_fifo);
 
   /* sem_rx contains count of inserted packets in FIFO, but FIFO can
    * overflow - fail smart.
@@ -832,7 +832,7 @@ static int dosend(FAR struct nrf24l01_dev_s *dev, FAR const uint8_t *data,
 {
   uint8_t status;
   uint8_t obsvalue;
-  int result;
+  int ret;
 
   /* Store the current lifecycle state in order to restore it after transmit
    * done.
@@ -863,8 +863,8 @@ static int dosend(FAR struct nrf24l01_dev_s *dev, FAR const uint8_t *data,
 
   /* Wait for IRQ (TX_DS or MAX_RT) - but don't hang on lost IRQ */
 
-  result = nxsem_tickwait(&dev->sem_tx, clock_systimer(),
-                          MSEC2TICK(NRF24L01_MAX_TX_IRQ_WAIT));
+  ret = nxsem_tickwait(&dev->sem_tx, clock_systimer(),
+                       MSEC2TICK(NRF24L01_MAX_TX_IRQ_WAIT));
 
   /* Re-acquire the SPI bus */
 
@@ -872,7 +872,7 @@ static int dosend(FAR struct nrf24l01_dev_s *dev, FAR const uint8_t *data,
 
   dev->tx_pending = false;
 
-  if (result < 0)
+  if (ret < 0)
     {
        wlerr("wait for irq failed\n");
        nrf24l01_flush_tx(dev);
@@ -884,7 +884,7 @@ static int dosend(FAR struct nrf24l01_dev_s *dev, FAR const uint8_t *data,
     {
       /* Transmit OK */
 
-      result = OK;
+      ret = OK;
       dev->lastxmitcount = (obsvalue & NRF24L01_ARC_CNT_MASK)
           >> NRF24L01_ARC_CNT_SHIFT;
 
@@ -893,7 +893,7 @@ static int dosend(FAR struct nrf24l01_dev_s *dev, FAR const uint8_t *data,
   else if (status & NRF24L01_MAX_RT)
     {
       wlinfo("MAX_RT! (lastxmitcount=%d)\n", dev->lastxmitcount);
-      result = -ECOMM;
+      ret = -ECOMM;
       dev->lastxmitcount = NRF24L01_XMIT_MAXRT;
 
       /* If no ACK packet is received the payload remains in TX fifo.  We
@@ -907,7 +907,7 @@ static int dosend(FAR struct nrf24l01_dev_s *dev, FAR const uint8_t *data,
       /* Unexpected... */
 
       wlerr("ERROR: No TX_DS nor MAX_RT bit set in STATUS reg!\n");
-      result = -EIO;
+      ret = -EIO;
     }
 
 out:
@@ -923,7 +923,7 @@ out:
   /* Restore state */
 
   nrf24l01_tostate(dev, prevstate);
-  return result;
+  return ret;
 }
 
 /****************************************************************************
@@ -956,7 +956,7 @@ static int nrf24l01_open(FAR struct file *filep)
 {
   FAR struct inode *inode;
   FAR struct nrf24l01_dev_s *dev;
-  int result;
+  int ret;
 
   wlinfo("Opening nRF24L01 dev\n");
 
@@ -968,31 +968,32 @@ static int nrf24l01_open(FAR struct file *filep)
 
   /* Get exclusive access to the driver data structure */
 
-  if (sem_wait(&dev->devsem) < 0)
+  ret = nxsem_wait(&dev->devsem);
+  if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Check if device is not already used */
 
   if (dev->nopens > 0)
     {
-      result = -EBUSY;
+      ret = -EBUSY;
       goto errout;
     }
 
-  result = nrf24l01_init(dev);
-  if (!result)
+  ret = nrf24l01_init(dev);
+  if (!ret)
     {
       dev->nopens++;
     }
 
 errout:
   nxsem_post(&dev->devsem);
-  return result;
+  return ret;
 }
 
 /****************************************************************************
@@ -1003,6 +1004,7 @@ static int nrf24l01_close(FAR struct file *filep)
 {
   FAR struct inode *inode;
   FAR struct nrf24l01_dev_s *dev;
+  int ret;
 
   wlinfo("Closing nRF24L01 dev\n");
   DEBUGASSERT(filep);
@@ -1013,12 +1015,13 @@ static int nrf24l01_close(FAR struct file *filep)
 
   /* Get exclusive access to the driver data structure */
 
-  if (sem_wait(&dev->devsem) < 0)
+  ret = nxsem_wait(&dev->devsem);
+  if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   nrf24l01_changestate(dev, ST_POWER_DOWN);
@@ -1040,7 +1043,7 @@ static ssize_t nrf24l01_read(FAR struct file *filep, FAR char *buffer,
 #else
   FAR struct nrf24l01_dev_s *dev;
   FAR struct inode *inode;
-  int result;
+  int ret;
 
   DEBUGASSERT(filep);
   inode = filep->f_inode;
@@ -1048,17 +1051,18 @@ static ssize_t nrf24l01_read(FAR struct file *filep, FAR char *buffer,
   DEBUGASSERT(inode && inode->i_private);
   dev = (FAR struct nrf24l01_dev_s *)inode->i_private;
 
-  if (sem_wait(&dev->devsem) < 0)
+  ret = nxsem_wait(&dev->devsem);
+  if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
-  result = nrf24l01_recv(dev, (uint8_t *)buffer, buflen, &dev->last_recvpipeno);
 
+  ret = nrf24l01_recv(dev, (uint8_t *)buffer, buflen, &dev->last_recvpipeno);
   nxsem_post(&dev->devsem);
-  return result;
+  return ret;
 #endif
 }
 
@@ -1071,7 +1075,7 @@ static ssize_t nrf24l01_write(FAR struct file *filep, FAR const char *buffer,
 {
   FAR struct nrf24l01_dev_s *dev;
   FAR struct inode *inode;
-  int result;
+  int ret;
 
   DEBUGASSERT(filep);
   inode = filep->f_inode;
@@ -1079,18 +1083,19 @@ static ssize_t nrf24l01_write(FAR struct file *filep, FAR const char *buffer,
   DEBUGASSERT(inode && inode->i_private);
   dev = (FAR struct nrf24l01_dev_s *)inode->i_private;
 
-  if (sem_wait(&dev->devsem) < 0)
+  ret = nxsem_wait(&dev->devsem);
+  if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
-  result = nrf24l01_send(dev, (const uint8_t *)buffer, buflen);
+  ret = nrf24l01_send(dev, (const uint8_t *)buffer, buflen);
 
   nxsem_post(&dev->devsem);
-  return result;
+  return ret;
 }
 
 /****************************************************************************
@@ -1101,7 +1106,7 @@ static int nrf24l01_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 {
   FAR struct inode *inode;
   FAR struct nrf24l01_dev_s *dev;
-  int result = OK;
+  int ret;
 
   wlinfo("cmd: %d arg: %ld\n", cmd, arg);
   DEBUGASSERT(filep);
@@ -1112,12 +1117,13 @@ static int nrf24l01_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 
   /* Get exclusive access to the driver data structure */
 
-  if (sem_wait(&dev->devsem) < 0)
+  ret = nxsem_wait(&dev->devsem);
+  if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Process the IOCTL by command */
@@ -1190,7 +1196,7 @@ static int nrf24l01_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 
       case NRF24L01IOC_GETRETRCFG:  /* Get retransmit params. arg: Pointer
                                      * to nrf24l01_retrcfg_t */
-        result = -ENOSYS;  /* TODO */
+        ret = -ENOSYS;  /* TODO */
         break;
 
       case NRF24L01IOC_SETPIPESCFG:
@@ -1263,7 +1269,7 @@ static int nrf24l01_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
         }
 
       case NRF24L01IOC_GETDATARATE:
-        result = -ENOSYS;  /* TODO */
+        ret = -ENOSYS;  /* TODO */
         break;
 
       case NRF24L01IOC_SETADDRWIDTH:
@@ -1321,12 +1327,12 @@ static int nrf24l01_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
         }
 
       default:
-        result = -ENOTTY;
+        ret = -ENOTTY;
         break;
     }
 
   nxsem_post(&dev->devsem);
-  return result;
+  return ret;
 }
 
 /****************************************************************************
@@ -1345,7 +1351,7 @@ static int nrf24l01_poll(FAR struct file *filep, FAR struct pollfd *fds,
 
   FAR struct inode *inode;
   FAR struct nrf24l01_dev_s *dev;
-  int result = OK;
+  int ret;
 
   wlinfo("setup: %d\n", (int)setup);
   DEBUGASSERT(filep && fds);
@@ -1356,12 +1362,13 @@ static int nrf24l01_poll(FAR struct file *filep, FAR struct pollfd *fds,
 
   /* Exclusive access */
 
-  if (sem_wait(&dev->devsem) < 0)
+  ret = nxsem_wait(&dev->devsem);
+  if (ret)  < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   /* Are we setting up the poll?  Or tearing it down? */
@@ -1372,7 +1379,7 @@ static int nrf24l01_poll(FAR struct file *filep, FAR struct pollfd *fds,
 
       if ((fds->events & POLLIN) == 0)
         {
-          result = -EDEADLK;
+          ret = -EDEADLK;
           goto errout;
         }
 
@@ -1383,7 +1390,7 @@ static int nrf24l01_poll(FAR struct file *filep, FAR struct pollfd *fds,
 
       if (dev->pfd)
         {
-          result = -EBUSY;
+          ret = -EBUSY;
           goto errout;
         }
 
@@ -1393,7 +1400,7 @@ static int nrf24l01_poll(FAR struct file *filep, FAR struct pollfd *fds,
        * don't wait for RX.
        */
 
-      sem_wait(&dev->sem_fifo);
+      (void)nxsem_wait(&dev->sem_fifo);
       if (dev->fifo_len > 0)
         {
           dev->pfd->revents |= POLLIN;  /* Data available for input */
@@ -1409,7 +1416,7 @@ static int nrf24l01_poll(FAR struct file *filep, FAR struct pollfd *fds,
 
 errout:
   nxsem_post(&dev->devsem);
-  return result;
+  return ret;
 #endif
 }
 #endif
@@ -1448,7 +1455,7 @@ int nrf24l01_register(FAR struct spi_dev_s *spi,
                       FAR struct nrf24l01_config_s *cfg)
 {
   FAR struct nrf24l01_dev_s *dev;
-  int result = OK;
+  int ret = OK;
 
 #ifdef CONFIG_WL_NRF24L01_RXSUPPORT
   uint8_t *rx_fifo;
@@ -1503,14 +1510,14 @@ int nrf24l01_register(FAR struct spi_dev_s *spi,
 
   wlinfo("Registering " DEV_NAME "\n");
 
-  result = register_driver(DEV_NAME, &nrf24l01_fops, 0666, dev);
-  if (result < 0)
+  ret = register_driver(DEV_NAME, &nrf24l01_fops, 0666, dev);
+  if (ret < 0)
     {
-      wlerr("ERROR: register_driver() failed: %d\n", result);
+      wlerr("ERROR: register_driver() failed: %d\n", ret);
       nrf24l01_unregister(dev);
     }
 
-  return result;
+  return ret;
 }
 
 /****************************************************************************
@@ -1523,7 +1530,7 @@ int nrf24l01_register(FAR struct spi_dev_s *spi,
 
 int nrf24l01_init(FAR struct nrf24l01_dev_s *dev)
 {
-  int result = OK;
+  int ret = OK;
   uint8_t features;
 
   CHECK_ARGS(dev);
@@ -1555,7 +1562,7 @@ int nrf24l01_init(FAR struct nrf24l01_dev_s *dev)
            * actual hardware.
            */
 
-          result = -ENODEV;
+          ret = -ENODEV;
           goto out;
         }
     }
@@ -1593,7 +1600,7 @@ int nrf24l01_init(FAR struct nrf24l01_dev_s *dev)
 
 out:
   nrf24l01_unlock(dev->spi);
-  return result;
+  return ret;
 }
 
 /****************************************************************************
@@ -1959,16 +1966,16 @@ int nrf24l01_changestate(FAR struct nrf24l01_dev_s *dev, nrf24l01_state_t state)
 int nrf24l01_send(FAR struct nrf24l01_dev_s *dev, FAR const uint8_t *data,
                   size_t datalen)
 {
-  int result;
+  int ret;
 
   CHECK_ARGS(dev && data && datalen <= NRF24L01_MAX_PAYLOAD_LEN);
 
   nrf24l01_lock(dev->spi);
 
-  result = dosend(dev, data, datalen);
+  ret = dosend(dev, data, datalen);
 
   nrf24l01_unlock(dev->spi);
-  return result;
+  return ret;
 }
 
 /****************************************************************************
@@ -1979,7 +1986,7 @@ int nrf24l01_sendto(FAR struct nrf24l01_dev_s *dev, FAR const uint8_t *data,
                     size_t datalen, FAR const uint8_t *destaddr)
 {
   bool pipeaddrchg = false;
-  int result;
+  int ret;
 
   nrf24l01_lock(dev->spi);
 
@@ -1996,7 +2003,7 @@ int nrf24l01_sendto(FAR struct nrf24l01_dev_s *dev, FAR const uint8_t *data,
       pipeaddrchg = true;
     }
 
-  result = dosend(dev, data, datalen);
+  ret = dosend(dev, data, datalen);
 
   if (pipeaddrchg)
     {
@@ -2008,7 +2015,7 @@ int nrf24l01_sendto(FAR struct nrf24l01_dev_s *dev, FAR const uint8_t *data,
     }
 
   nrf24l01_unlock(dev->spi);
-  return result;
+  return ret;
 }
 
 /****************************************************************************
@@ -2028,19 +2035,19 @@ int nrf24l01_lastxmitcount(FAR struct nrf24l01_dev_s *dev)
 ssize_t nrf24l01_recv(struct nrf24l01_dev_s *dev, uint8_t *buffer,
                       size_t buflen, uint8_t *recvpipe)
 {
-  if (sem_wait(&dev->sem_rx) != 0)
+  int ret = nxsem_wait(&dev->sem_rx);
+  if (ret < 0)
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      DEBUGASSERT(errno == EINTR);
-      return -EINTR;
+      DEBUGASSERT(ret == -EINTR);
+      return ret;
     }
 
   return fifoget(dev, buffer, buflen, recvpipe);
 }
 #endif
 
-
 /****************************************************************************
  * Name: nrf24l01_dumpregs
  ****************************************************************************/
diff --git a/drivers/wireless/spirit/drivers/spirit_netdev.c b/drivers/wireless/spirit/drivers/spirit_netdev.c
index c4250dac37..9e9b0655c0 100644
--- a/drivers/wireless/spirit/drivers/spirit_netdev.c
+++ b/drivers/wireless/spirit/drivers/spirit_netdev.c
@@ -486,10 +486,21 @@ static struct spirit_pktstack_address_s g_addrinit =
 
 static void spirit_rxlock(FAR struct spirit_driver_s *priv)
 {
-  while (sem_wait(&priv->rxsem) < 0)
+  int ret;
+
+  do
     {
-      DEBUGASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->rxsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
@@ -527,10 +538,21 @@ static inline void spirit_rxunlock(FAR struct spirit_driver_s *priv)
 
 static void spirit_txlock(FAR struct spirit_driver_s *priv)
 {
-  while (sem_wait(&priv->txsem) < 0)
+  int ret;
+
+  do
     {
-      DEBUGASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&priv->txsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/fs/aio/aio_initialize.c b/fs/aio/aio_initialize.c
index 4c606b0444..2f7d342b3f 100644
--- a/fs/aio/aio_initialize.c
+++ b/fs/aio/aio_initialize.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * fs/aio/aio_initialize.c
  *
- *   Copyright (C) 2014 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -157,12 +157,21 @@ void aio_lock(void)
     }
   else
     {
+      int ret;
+
       /* No.. take the semaphore */
 
-      while (sem_wait(&g_aio_exclsem) < 0)
+      do
         {
-          DEBUGASSERT(get_errno() == EINTR);
+          ret = nxsem_wait(&g_aio_exclsem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
+           */
+
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
 
       /* And mark it as ours */
 
@@ -215,15 +224,25 @@ void aio_unlock(void)
 FAR struct aio_container_s *aioc_alloc(void)
 {
   FAR struct aio_container_s *aioc;
+  int ret;
 
   /* Take a count from semaphore, thus guaranteeing that we have an AIO
    * container set aside for us.
    */
 
-  while (sem_wait(&g_aioc_freesem) < 0)
+  do
     {
-      DEBUGASSERT(get_errno() == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&g_aioc_freesem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   /* Get our AIO container */
 
diff --git a/fs/driver/fs_blockproxy.c b/fs/driver/fs_blockproxy.c
index 6f2c9d0704..1f15370bcd 100644
--- a/fs/driver/fs_blockproxy.c
+++ b/fs/driver/fs_blockproxy.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * fs/driver/fs_blockproxy.c
  *
- *   Copyright (C) 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -100,10 +100,17 @@ static FAR char *unique_chardev(void)
     {
       /* Get the semaphore protecting the path number */
 
-      while (sem_wait(&g_devno_sem) < 0)
+      do
         {
-          DEBUGASSERT(errno == EINTR);
+          ret = nxsem_wait(&g_devno_sem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
+           */
+
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
 
       /* Get the next device number and release the semaphore */
 
diff --git a/fs/fat/fs_fat32util.c b/fs/fat/fs_fat32util.c
index 37d93ca633..ad4701c958 100644
--- a/fs/fat/fs_fat32util.c
+++ b/fs/fat/fs_fat32util.c
@@ -1,7 +1,8 @@
 /****************************************************************************
  * fs/fat/fs_fat32util.c
  *
- *   Copyright (C) 2007-2009, 2011, 2013, 2015 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2007-2009, 2011, 2013, 2015, 2017 Gregory Nutt. All
+ *     rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References:
@@ -356,16 +357,21 @@ void fat_putuint32(FAR uint8_t *ptr, uint32_t value32)
 
 void fat_semtake(struct fat_mountpt_s *fs)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&fs->fs_sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if
-       * the wait was awakened by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&fs->fs_sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(*get_errno_ptr() == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/fs/hostfs/hostfs.c b/fs/hostfs/hostfs.c
index 39122300ce..7e4234948a 100644
--- a/fs/hostfs/hostfs.c
+++ b/fs/hostfs/hostfs.c
@@ -166,16 +166,21 @@ const struct mountpt_operations hostfs_operations =
 
 void hostfs_semtake(FAR struct hostfs_mountpt_s *fs)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(fs->fs_sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if
-       * the wait was awakened by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(fs->fs_sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(*get_errno_ptr() == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/fs/inode/fs_filedetach.c b/fs/inode/fs_filedetach.c
index ac5e8413ec..96306dde7c 100644
--- a/fs/inode/fs_filedetach.c
+++ b/fs/inode/fs_filedetach.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * fs/inode/fs_filedetach.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -58,16 +58,21 @@
 
 static inline void _files_semtake(FAR struct filelist *list)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&list->fl_sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if
-       * the wait was awakened by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&list->fl_sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      DEBUGASSERT(get_errno() == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/fs/inode/fs_files.c b/fs/inode/fs_files.c
index 6421234554..82aef57657 100644
--- a/fs/inode/fs_files.c
+++ b/fs/inode/fs_files.c
@@ -1,7 +1,8 @@
 /****************************************************************************
  * fs/inode/fs_files.c
  *
- *   Copyright (C) 2007-2009, 2011-2013, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2007-2009, 2011-2013, 2016-2017 Gregory Nutt. All rights
+ *     reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -61,16 +62,21 @@
 
 static void _files_semtake(FAR struct filelist *list)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&list->fl_sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if
-       * the wait was awakened by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&list->fl_sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(get_errno() == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/fs/inode/fs_inode.c b/fs/inode/fs_inode.c
index ba5b7200ea..bb774ba81f 100644
--- a/fs/inode/fs_inode.c
+++ b/fs/inode/fs_inode.c
@@ -1,7 +1,8 @@
 /****************************************************************************
  * fs/inode/fs_inode.c
  *
- *   Copyright (C) 2007-2009, 2011-2012, 2016-2017 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2007-2009, 2011-2012, 2016-2017 Gregory Nutt. All rights
+ *     reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -139,14 +140,19 @@ void inode_semtake(void)
 
   else
     {
-      while (sem_wait(&g_inode_sem.sem) != 0)
+      int ret;
+
+      do
         {
-          /* The only case that an error should occr here is if
-           * the wait was awakened by a signal.
+          ret = nxsem_wait(&g_inode_sem.sem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(get_errno() == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
 
       /* No we hold the semaphore */
 
diff --git a/fs/mmap/fs_munmap.c b/fs/mmap/fs_munmap.c
index c25b0d9e0c..89ef809041 100644
--- a/fs/mmap/fs_munmap.c
+++ b/fs/mmap/fs_munmap.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * fs/mmap/fs_munmap.c
  *
- *   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -120,10 +120,11 @@ int munmap(FAR void *start, size_t length)
   /* Find a region containing this start and length in the list of regions */
 
   rammap_initialize();
-  ret = sem_wait(&g_rammaps.exclsem);
+  ret = nxsem_wait(&g_rammaps.exclsem);
   if (ret < 0)
     {
-      return ERROR;
+      errcode = ret;
+      goto errout;
     }
 
   /* Seach the list of regions */
@@ -205,6 +206,8 @@ int munmap(FAR void *start, size_t length)
 
 errout_with_semaphore:
   nxsem_post(&g_rammaps.exclsem);
+
+errout:
   set_errno(errcode);
   return ERROR;
 }
diff --git a/fs/mmap/fs_rammap.c b/fs/mmap/fs_rammap.c
index 723f85d532..3f8d992489 100644
--- a/fs/mmap/fs_rammap.c
+++ b/fs/mmap/fs_rammap.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * fs/mmap/fs_rammmap.c
  *
- *   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -220,10 +220,11 @@ FAR void *rammap(int fd, size_t length, off_t offset)
   /* Add the buffer to the list of regions */
 
   rammap_initialize();
-  ret = sem_wait(&g_rammaps.exclsem);
+  ret = nxsem_wait(&g_rammaps.exclsem);
   if (ret < 0)
     {
-      goto errout_with_errno;
+      errcode = -ret;
+      goto errout_with_region;
     }
 
   map->flink  = g_rammaps.head;
@@ -234,13 +235,16 @@ FAR void *rammap(int fd, size_t length, off_t offset)
 
 errout_with_region:
   kumm_free(alloc);
+
 errout:
   set_errno(errcode);
   return MAP_FAILED;
 
+#ifndef CONFIG_DEBUG_FS
 errout_with_errno:
   kumm_free(alloc);
   return MAP_FAILED;
+#endif
 }
 
 #endif /* CONFIG_FS_RAMMAP */
diff --git a/fs/nfs/nfs_util.c b/fs/nfs/nfs_util.c
index ed232cca25..59fd1eb8fa 100644
--- a/fs/nfs/nfs_util.c
+++ b/fs/nfs/nfs_util.c
@@ -127,16 +127,21 @@ static inline int nfs_pathsegment(FAR const char **path, FAR char *buffer,
 
 void nfs_semtake(struct nfsmount *nmp)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&nmp->nm_sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if
-       * the wait was awakened by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&nmp->nm_sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(*get_errno_ptr() == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/fs/nxffs/nxffs_dirent.c b/fs/nxffs/nxffs_dirent.c
index 93353a1744..9afe984867 100644
--- a/fs/nxffs/nxffs_dirent.c
+++ b/fs/nxffs/nxffs_dirent.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * fs/nxffs/nxffs_dirent.c
  *
- *   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References: Linux/Documentation/filesystems/romfs.txt
@@ -80,8 +80,8 @@ int nxffs_opendir(FAR struct inode *mountpt, FAR const char *relpath,
   /* Recover the file system state from the NuttX inode instance */
 
   volume = mountpt->i_private;
-  ret = sem_wait(&volume->exclsem);
-  if (ret != OK)
+  ret = nxsem_wait(&volume->exclsem);
+  if (ret < 0)
     {
       goto errout;
     }
@@ -101,6 +101,7 @@ int nxffs_opendir(FAR struct inode *mountpt, FAR const char *relpath,
 
 errout_with_semaphore:
   nxsem_post(&volume->exclsem);
+
 errout:
   return ret;
 }
@@ -126,8 +127,8 @@ int nxffs_readdir(FAR struct inode *mountpt, FAR struct fs_dirent_s *dir)
   /* Recover the file system state from the NuttX inode instance */
 
   volume = mountpt->i_private;
-  ret = sem_wait(&volume->exclsem);
-  if (ret != OK)
+  ret = nxsem_wait(&volume->exclsem);
+  if (ret < 0)
     {
       goto errout;
     }
@@ -158,6 +159,7 @@ int nxffs_readdir(FAR struct inode *mountpt, FAR struct fs_dirent_s *dir)
     }
 
   nxsem_post(&volume->exclsem);
+
 errout:
   return ret;
 }
@@ -184,8 +186,8 @@ int nxffs_rewinddir(FAR struct inode *mountpt, FAR struct fs_dirent_s *dir)
   /* Recover the file system state from the NuttX inode instance */
 
   volume = mountpt->i_private;
-  ret = sem_wait(&volume->exclsem);
-  if (ret != OK)
+  ret = nxsem_wait(&volume->exclsem);
+  if (ret < 0)
     {
       goto errout;
     }
@@ -196,6 +198,7 @@ int nxffs_rewinddir(FAR struct inode *mountpt, FAR struct fs_dirent_s *dir)
   ret = OK;
 
   nxsem_post(&volume->exclsem);
+
 errout:
   return ret;
 }
diff --git a/fs/nxffs/nxffs_ioctl.c b/fs/nxffs/nxffs_ioctl.c
index 3988edf37f..e80d4d265a 100644
--- a/fs/nxffs/nxffs_ioctl.c
+++ b/fs/nxffs/nxffs_ioctl.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * fs/nxffs/nxffs_ioctl.c
  *
- *   Copyright (C) 2011, 2013 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011, 2013, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References: Linux/Documentation/filesystems/romfs.txt
@@ -84,11 +84,10 @@ int nxffs_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
    * protects the open file list.
    */
 
-  ret = sem_wait(&volume->exclsem);
-  if (ret != OK)
+  ret = nxsem_wait(&volume->exclsem);
+  if (ret < 0)
     {
-      ret = -get_errno();
-      ferr("ERROR: sem_wait failed: %d\n", ret);
+      ferr("ERROR: nxsem_wait failed: %d\n", ret);
       goto errout;
     }
 
diff --git a/fs/nxffs/nxffs_open.c b/fs/nxffs/nxffs_open.c
index 814a1335ad..f5a65e10d2 100644
--- a/fs/nxffs/nxffs_open.c
+++ b/fs/nxffs/nxffs_open.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * fs/nxffs/nxffs_open.c
  *
- *   Copyright (C) 2011, 2013 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011, 2013, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References: Linux/Documentation/filesystems/romfs.txt
@@ -388,11 +388,10 @@ static inline int nxffs_wropen(FAR struct nxffs_volume_s *volume,
    * in FLASH, only a single file may be extending the FLASH region.
    */
 
-  ret = sem_wait(&volume->wrsem);
-  if (ret != OK)
+  ret = nxsem_wait(&volume->wrsem);
+  if (ret < 0)
     {
-      ferr("ERROR: sem_wait failed: %d\n", ret);
-      ret = -get_errno();
+      ferr("ERROR: nxsem_wait failed: %d\n", ret);
       goto errout;
     }
 
@@ -401,11 +400,10 @@ static inline int nxffs_wropen(FAR struct nxffs_volume_s *volume,
    * after wrsem to avoid deadlocks.
    */
 
-  ret = sem_wait(&volume->exclsem);
-  if (ret != OK)
+  ret = nxsem_wait(&volume->exclsem);
+  if (ret < 0)
     {
-      ferr("ERROR: sem_wait failed: %d\n", ret);
-      ret = -get_errno();
+      ferr("ERROR: nxsem_wait failed: %d\n", ret);
       goto errout_with_wrsem;
     }
 
@@ -699,11 +697,10 @@ static inline int nxffs_rdopen(FAR struct nxffs_volume_s *volume,
    * protects the open file list.
    */
 
-  ret = sem_wait(&volume->exclsem);
+  ret = nxsem_wait(&volume->exclsem);
   if (ret != OK)
     {
-      ferr("ERROR: sem_wait failed: %d\n", ret);
-      ret = -get_errno();
+      ferr("ERROR: nxsem_wait failed: %d\n", ret);
       goto errout;
     }
 
@@ -1145,11 +1142,10 @@ int nxffs_close(FAR struct file *filep)
    * protects the open file list.
    */
 
-  ret = sem_wait(&volume->exclsem);
+  ret = nxsem_wait(&volume->exclsem);
   if (ret != OK)
     {
-      ret = -get_errno();
-      ferr("ERROR: sem_wait failed: %d\n", ret);
+      ferr("ERROR: nxsem_wait failed: %d\n", ret);
       goto errout;
     }
 
diff --git a/fs/nxffs/nxffs_read.c b/fs/nxffs/nxffs_read.c
index cc48fcf09a..49014d6144 100644
--- a/fs/nxffs/nxffs_read.c
+++ b/fs/nxffs/nxffs_read.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * fs/nxffs/nxffs_read.c
  *
- *   Copyright (C) 2011, 2013 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011, 2013, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References: Linux/Documentation/filesystems/romfs.txt
@@ -169,11 +169,10 @@ ssize_t nxffs_read(FAR struct file *filep, FAR char *buffer, size_t buflen)
    * protects the open file list.
    */
 
-  ret = sem_wait(&volume->exclsem);
-  if (ret != OK)
+  ret = nxsem_wait(&volume->exclsem);
+  if (ret < 0)
     {
-      ret = -get_errno();
-      ferr("ERROR: sem_wait failed: %d\n", ret);
+      ferr("ERROR: nxsem_wait failed: %d\n", ret);
       goto errout;
     }
 
diff --git a/fs/nxffs/nxffs_stat.c b/fs/nxffs/nxffs_stat.c
index b77a6e8a00..5d2ea2927c 100644
--- a/fs/nxffs/nxffs_stat.c
+++ b/fs/nxffs/nxffs_stat.c
@@ -80,8 +80,8 @@ int nxffs_statfs(FAR struct inode *mountpt, FAR struct statfs *buf)
   /* Get the mountpoint private data from the NuttX inode structure */
 
   volume = mountpt->i_private;
-  ret = sem_wait(&volume->exclsem);
-  if (ret != OK)
+  ret = nxsem_wait(&volume->exclsem);
+  if (ret < 0)
     {
       goto errout;
     }
@@ -99,6 +99,7 @@ int nxffs_statfs(FAR struct inode *mountpt, FAR struct statfs *buf)
   ret            = OK;
 
   nxsem_post(&volume->exclsem);
+
 errout:
   return ret;
 }
@@ -126,7 +127,7 @@ int nxffs_stat(FAR struct inode *mountpt, FAR const char *relpath,
   /* Get the mountpoint private data from the NuttX inode structure */
 
   volume = mountpt->i_private;
-  ret = sem_wait(&volume->exclsem);
+  ret = nxsem_wait(&volume->exclsem);
   if (ret != OK)
     {
       goto errout;
@@ -175,6 +176,7 @@ int nxffs_stat(FAR struct inode *mountpt, FAR const char *relpath,
 
 errout_with_semaphore:
   nxsem_post(&volume->exclsem);
+
 errout:
   return ret;
 }
@@ -212,12 +214,11 @@ int nxffs_fstat(FAR const struct file *filep, FAR struct stat *buf)
    * protects the open file list.
    */
 
-  ret = sem_wait(&volume->exclsem);
+  ret = nxsem_wait(&volume->exclsem);
   if (ret != OK)
     {
-      int errcode = get_errno();
-      ferr("ERROR: sem_wait failed: %d\n", errcode);
-      return -errcode;
+      ferr("ERROR: nxsem_wait failed: %d\n", ret);
+      return ret;
     }
 
   /* Return status information based on the directory entry */
diff --git a/fs/nxffs/nxffs_unlink.c b/fs/nxffs/nxffs_unlink.c
index 6ae0c30ffc..786acc1682 100644
--- a/fs/nxffs/nxffs_unlink.c
+++ b/fs/nxffs/nxffs_unlink.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * fs/nxffs/nxffs_unlink.c
  *
- *   Copyright (C) 2011, 2013 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011, 2013, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References: Linux/Documentation/filesystems/romfs.txt
@@ -157,7 +157,7 @@ int nxffs_unlink(FAR struct inode *mountpt, FAR const char *relpath)
   /* Get the mountpoint private data from the NuttX inode structure */
 
   volume = mountpt->i_private;
-  ret = sem_wait(&volume->exclsem);
+  ret = nxsem_wait(&volume->exclsem);
   if (ret != OK)
     {
       goto errout;
@@ -168,6 +168,7 @@ int nxffs_unlink(FAR struct inode *mountpt, FAR const char *relpath)
   ret = nxffs_rminode(volume, relpath);
 
   nxsem_post(&volume->exclsem);
+
 errout:
   return ret;
 }
diff --git a/fs/nxffs/nxffs_write.c b/fs/nxffs/nxffs_write.c
index 25e6bc75c3..ba51895cce 100644
--- a/fs/nxffs/nxffs_write.c
+++ b/fs/nxffs/nxffs_write.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * fs/nxffs/nxffs_write.c
  *
- *   Copyright (C) 2011, 2013 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011, 2013, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References: Linux/Documentation/filesystems/romfs.txt
@@ -455,11 +455,10 @@ ssize_t nxffs_write(FAR struct file *filep, FAR const char *buffer, size_t bufle
    * protects the open file list.
    */
 
-  ret = sem_wait(&volume->exclsem);
-  if (ret != OK)
+  ret = nxsem_wait(&volume->exclsem);
+  if (ret < 0)
     {
-      ret = -get_errno();
-      ferr("ERROR: sem_wait failed: %d\n", ret);
+      ferr("ERROR: nxsem_wait failed: %d\n", ret);
       goto errout;
     }
 
diff --git a/fs/romfs/fs_romfsutil.c b/fs/romfs/fs_romfsutil.c
index b76cb12b92..145f349bc6 100644
--- a/fs/romfs/fs_romfsutil.c
+++ b/fs/romfs/fs_romfsutil.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * rm/romfs/fs_romfsutil.c
  *
- *   Copyright (C) 2008-2009, 2013 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2008-2009, 2013, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * References: Linux/Documentation/filesystems/romfs.txt
@@ -353,16 +353,21 @@ static inline int romfs_searchdir(struct romfs_mountpt_s *rm,
 
 void romfs_semtake(struct romfs_mountpt_s *rm)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(&rm->rm_sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if
-       * the wait was awakened by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&rm->rm_sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(*get_errno_ptr() == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/fs/semaphore/sem_open.c b/fs/semaphore/sem_open.c
index 4bc91daeb0..c621924d1d 100644
--- a/fs/semaphore/sem_open.c
+++ b/fs/semaphore/sem_open.c
@@ -70,7 +70,7 @@
  *   task.  Following a call to sem_open() with the semaphore name, the task
  *   may reference the semaphore associated with name using the address
  *   returned by this call.  The semaphore may be used in subsequent calls
- *   to sem_wait(), sem_trywait(), and sem_post().  The semaphore remains
+ *   to nxsem_wait(), sem_trywait(), and sem_post().  The semaphore remains
  *   usable until the semaphore is closed by a successful call to sem_close().
  *
  *   If a task makes multiple calls to sem_open() with the same name, then
diff --git a/fs/smartfs/smartfs_utils.c b/fs/smartfs/smartfs_utils.c
index 7a6fcbeb3b..8b97b70d5e 100644
--- a/fs/smartfs/smartfs_utils.c
+++ b/fs/smartfs/smartfs_utils.c
@@ -75,16 +75,21 @@ static struct smartfs_mountpt_s *g_mounthead = NULL;
 
 void smartfs_semtake(struct smartfs_mountpt_s *fs)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(fs->fs_sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if
-       * the wait was awakened by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(fs->fs_sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      ASSERT(*get_errno_ptr() == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/fs/tmpfs/fs_tmpfs.c b/fs/tmpfs/fs_tmpfs.c
index 39e444b231..3725bd0cc4 100644
--- a/fs/tmpfs/fs_tmpfs.c
+++ b/fs/tmpfs/fs_tmpfs.c
@@ -221,14 +221,19 @@ static void tmpfs_lock_reentrant(FAR struct tmpfs_sem_s *sem)
 
   else
     {
-      while (sem_wait(&sem->ts_sem) != 0)
+      int ret;
+
+      do
         {
-          /* The only case that an error should occr here is if
-           * the wait was awakened by a signal.
+          ret = nxsem_wait(&sem->ts_sem);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          DEBUGASSERT(get_errno() == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
 
       /* No we hold the semaphore */
 
diff --git a/fs/unionfs/fs_unionfs.c b/fs/unionfs/fs_unionfs.c
index b8b0922d03..97717860b0 100644
--- a/fs/unionfs/fs_unionfs.c
+++ b/fs/unionfs/fs_unionfs.c
@@ -249,20 +249,19 @@ static int unionfs_semtake(FAR struct unionfs_inode_s *ui, bool noint)
 
   do
     {
-      ret = sem_wait(&ui->ui_exclsem);
+      ret = nxsem_wait(&ui->ui_exclsem);
       if (ret < 0)
         {
-          int errcode = errno;
-          DEBUGASSERT(errcode == EINTR);
+          DEBUGASSERT(ret == -EINTR);
           if (!noint)
             {
-              return -errcode;
+              return ret;
             }
         }
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
diff --git a/fs/vfs/fs_fdopen.c b/fs/vfs/fs_fdopen.c
index 1dd438ea4b..6125db8dbe 100644
--- a/fs/vfs/fs_fdopen.c
+++ b/fs/vfs/fs_fdopen.c
@@ -208,10 +208,11 @@ FAR struct file_struct *fs_fdopen(int fd, int oflags, FAR struct tcb_s *tcb)
 
   /* Find an unallocated FILE structure in the stream list */
 
-  ret = sem_wait(&slist->sl_sem);
-  if (ret != OK)
+  ret = nxsem_wait(&slist->sl_sem);
+  if (ret < 0)
     {
-      goto errout_with_errno;
+      errcode = -ret;
+      goto errout;
     }
 
   for (i = 0 ; i < CONFIG_NFILE_STREAMS; i++)
@@ -280,6 +281,5 @@ errout_with_sem:
 
 errout:
   set_errno(errcode);
-errout_with_errno:
   return NULL;
 }
diff --git a/fs/vfs/fs_poll.c b/fs/vfs/fs_poll.c
index 696f2f60dd..81480cbe3d 100644
--- a/fs/vfs/fs_poll.c
+++ b/fs/vfs/fs_poll.c
@@ -74,21 +74,18 @@
 
 static int poll_semtake(FAR sem_t *sem)
 {
+  int ret;
+
   /* Take the semaphore (perhaps waiting) */
 
-  if (sem_wait(sem) < 0)
-    {
-      int errcode = get_errno();
+  ret = nxsem_wait(sem);
 
-      /* The only case that an error should occur here is if the wait were
-       * awakened by a signal.
-       */
+  /* The only case that an error should occur here is if the wait were
+   * awakened by a signal.
+   */
 
-      DEBUGASSERT(errcode == EINTR);
-      return -errcode;
-    }
-
-  return OK;
+  DEBUGASSERT(ret == OK || ret == -EINTR);
+  return ret;
 }
 
 /****************************************************************************
diff --git a/graphics/nxterm/nxterm.h b/graphics/nxterm/nxterm.h
index 6f9747aa34..a43838b747 100644
--- a/graphics/nxterm/nxterm.h
+++ b/graphics/nxterm/nxterm.h
@@ -190,7 +190,7 @@ extern const struct file_operations g_nxterm_drvrops;
 int nxterm_semwait(FAR struct nxterm_state_s *priv);
 int nxterm_sempost(FAR struct nxterm_state_s *priv);
 #else
-#  define nxterm_semwait(p) sem_wait(&p->exclsem)
+#  define nxterm_semwait(p) nxsem_wait(&p->exclsem)
 #  define nxterm_sempost(p) nxsem_post(&p->exclsem)
 #endif
 
diff --git a/graphics/nxterm/nxterm_kbdin.c b/graphics/nxterm/nxterm_kbdin.c
index 6aeca648ef..5abe774d35 100644
--- a/graphics/nxterm/nxterm_kbdin.c
+++ b/graphics/nxterm/nxterm_kbdin.c
@@ -163,7 +163,7 @@ ssize_t nxterm_read(FAR struct file *filep, FAR char *buffer, size_t len)
            * but will be re-enabled while we are waiting.
            */
 
-          ret = sem_wait(&priv->waitsem);
+          ret = nxterm_semwait(&priv->waitsem);
 
           /* Pre-emption will be disabled when we return.  So the decrementing
            * nwaiters here is safe.
@@ -187,9 +187,7 @@ ssize_t nxterm_read(FAR struct file *filep, FAR char *buffer, size_t len)
 
           if (ret < 0)
             {
-              /* No.. One of the two sem_wait's failed. */
-
-              int errval = errno;
+              /* No.. One of the two nxterm_semwait's failed. */
 
               gerr("ERROR: nxterm_semwait failed\n");
 
@@ -197,11 +195,11 @@ ssize_t nxterm_read(FAR struct file *filep, FAR char *buffer, size_t len)
                * we received the signal?
                */
 
-              if (errval != EINTR || nread >= 0)
+              if (ret != -EINTR || nread >= 0)
                 {
                   /* Yes.. return the error. */
 
-                  nread = -errval;
+                  nread = ret;
                 }
 
               /* Break out to return what we have.  Note, we can't exactly
diff --git a/graphics/nxterm/nxterm_sem.c b/graphics/nxterm/nxterm_sem.c
index e5881d1590..3ed10037f3 100644
--- a/graphics/nxterm/nxterm_sem.c
+++ b/graphics/nxterm/nxterm_sem.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * nuttx/graphics/nxterm/nxterm_sem.c
  *
- *   Copyright (C) 2012 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -80,20 +80,20 @@ int nxterm_semwait(FAR struct nxterm_state_s *priv)
     {
       /* No.. then wait until the thread that does hold it is finished with it */
 
-      ret = sem_wait(&priv->exclsem);
+      ret = nxsem_wait(&priv->exclsem);
       if (ret == OK)
         {
           /* No I hold the semaphore */
 
           priv->holder = me;
         }
+
       return ret;
     }
 
   /* Abort, abort, abort!  I have been re-entered */
 
-  set_errno(EBUSY);
-  return ERROR;
+  return -EBUSY;
 }
 
 int nxterm_sempost(FAR struct nxterm_state_s *priv)
diff --git a/graphics/vnc/server/vnc_fbdev.c b/graphics/vnc/server/vnc_fbdev.c
index 00b171b70b..055647c696 100644
--- a/graphics/vnc/server/vnc_fbdev.c
+++ b/graphics/vnc/server/vnc_fbdev.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * graphics/vnc/server/vnc_fbdev.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -482,7 +482,7 @@ static int vnc_start_server(int display)
 
 static inline int vnc_wait_start(int display)
 {
-  int errcode;
+  int ret = OK;
 
   /* Check if there has been a session allocated yet.  This is one of the
    * first things that the VNC server will do with the kernel thread is
@@ -502,22 +502,20 @@ static inline int vnc_wait_start(int display)
        * conditions here, but I think none that are fatal.
        */
 
-      while (sem_wait(&g_fbstartup[display].fbinit) < 0)
+      do
         {
-          errcode = get_errno();
+          ret = nxsem_wait(&g_fbstartup[display].fbinit);
 
-          /* sem_wait() should fail only if it is interrupt by a signal. */
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
+           */
 
-          DEBUGASSERT(errcode == EINTR);
-          if (errcode != EINTR)
-            {
-              DEBUGASSERT(errcode > 0);
-              return -errcode;
-            }
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
     }
 
-  return OK;
+  return ret;
 }
 
 /****************************************************************************
@@ -563,19 +561,20 @@ static inline int vnc_wait_connect(int display)
        * conditions here, but I think none that are fatal.
        */
 
-      while (sem_wait(&g_fbstartup[display].fbconnect) < 0)
+      do
         {
-          errcode = get_errno();
+          ret = nxsem_wait(&g_fbstartup[display].fbconnect);
 
-          /* sem_wait() should fail only if it is interrupt by a signal. */
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
+           */
 
-          DEBUGASSERT(errcode == EINTR);
-          if (errcode != EINTR)
+          if (ret < 0 && ret != -EINTR)
             {
-              DEBUGASSERT(errcode > 0);
-              return -errcode;
+              return ret;
             }
         }
+      while (ret == -EINTR);
 
       /* We were awakened.  A result of -EBUSY means that the negotiation
        * is not complete.  Why would we be awakened in that case?  Some
diff --git a/graphics/vnc/server/vnc_server.c b/graphics/vnc/server/vnc_server.c
index 858ef9deee..b16ef074f4 100644
--- a/graphics/vnc/server/vnc_server.c
+++ b/graphics/vnc/server/vnc_server.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * graphics/vnc/vnc_server.c
  *
- *   Copyright (C) 2016=-2017 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/graphics/vnc/server/vnc_updater.c b/graphics/vnc/server/vnc_updater.c
index c7937ea3c1..3a163066af 100644
--- a/graphics/vnc/server/vnc_updater.c
+++ b/graphics/vnc/server/vnc_updater.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * graphics/vnc/vnc_updater.c
  *
- *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -125,11 +125,21 @@ static void vnc_sem_debug(FAR struct vnc_session_s *session,
   int queuecount;
   int freewaiting;
   int queuewaiting;
+  int ret;
 
-  while (sem_wait(&g_errsem) < 0)
+  do
     {
-      DEBUGASSERT(get_errno() == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&g_errsem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   /* Count structures in the list */
 
@@ -193,19 +203,29 @@ static FAR struct vnc_fbupdate_s *
 vnc_alloc_update(FAR struct vnc_session_s *session)
 {
   FAR struct vnc_fbupdate_s *update;
+  int ret;
 
   /* Reserve one element from the free list.  Lock the scheduler to assure
-   * that the sq_remfirst() and the successful return from sem_wait are
+   * that the sq_remfirst() and the successful return from nxsem_wait are
    * atomic.  Of course, the scheduler will be unlocked while we wait.
    */
 
   sched_lock();
   vnc_sem_debug(session, "Before alloc", 0);
 
-  while (sem_wait(&session->freesem) < 0)
+  do
     {
-      DEBUGASSERT(get_errno() == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&session->freesem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   /* It is reserved.. go get it */
 
@@ -276,20 +296,30 @@ static FAR struct vnc_fbupdate_s *
 vnc_remove_queue(FAR struct vnc_session_s *session)
 {
   FAR struct vnc_fbupdate_s *rect;
+  int ret;
 
   /* Reserve one element from the list of queued rectangle.  Lock the
    * scheduler to assure that the sq_remfirst() and the successful return
-   * from sem_wait are atomic.  Of course, the scheduler will be unlocked
+   * from nxsem_wait are atomic.  Of course, the scheduler will be unlocked
    * while we wait.
    */
 
   sched_lock();
   vnc_sem_debug(session, "Before remove", 0);
 
-  while (sem_wait(&session->queuesem) < 0)
+  do
     {
-      DEBUGASSERT(get_errno() == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&session->queuesem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   /* It is reserved.. go get it */
 
diff --git a/include/nuttx/semaphore.h b/include/nuttx/semaphore.h
index 7a99ac4a20..692d3e386d 100644
--- a/include/nuttx/semaphore.h
+++ b/include/nuttx/semaphore.h
@@ -150,6 +150,36 @@ int nxsem_init(FAR sem_t *sem, int pshared, unsigned int value);
 
 int nxsem_destroy (FAR sem_t *sem);
 
+/****************************************************************************
+ * Name: nxsem_wait
+ *
+ * Description:
+ *   This function attempts to lock the semaphore referenced by 'sem'.  If
+ *   the semaphore value is (<=) zero, then the calling task will not return
+ *   until it successfully acquires the lock.
+ *
+ *   This is an internal OS interface.  It is functionally equivalent to
+ *   sem_wait except that:
+ *
+ *   - It is not a cancellaction point, and
+ *   - It does not modify the errno value.
+ *
+ * Parameters:
+ *   sem - Semaphore descriptor.
+ *
+ * Return Value:
+ *   This is an internal OS interface and should not be used by applications.
+ *   It follows the NuttX internal error return policy:  Zero (OK) is
+ *   returned on success.  A negated errno value is returned on failure.
+ *   Possible returned errors:
+ *
+ *   - EINVAL:  Invalid attempt to get the semaphore
+ *   - EINTR:   The wait was interrupted by the receipt of a signal.
+ *
+ ****************************************************************************/
+
+int nxsem_wait(FAR sem_t *sem);
+
 /****************************************************************************
  * Name: nxsem_tickwait
  *
diff --git a/libc/semaphore/sem_init.c b/libc/semaphore/sem_init.c
index e1f5c1f532..b5ca507c3f 100644
--- a/libc/semaphore/sem_init.c
+++ b/libc/semaphore/sem_init.c
@@ -56,12 +56,12 @@
  * Description:
  *   This function initializes the UNAMED semaphore sem. Following a
  *   successful call to nxsem_init(), the semaphore may be used in subsequent
- *   calls to nxsem_wait(), nxnxsem_post(), and nxsem_trywait().  The semaphore
+ *   calls to nxsem_wait(), nxsem_post(), and nxsem_trywait().  The semaphore
  *   remains usable until it is destroyed.
  *
  *   Only sem itself may be used for performing synchronization. The result
  *   of referring to copies of sem in calls to nxsem_wait(), nxsem_trywait(),
- *   nxnxsem_post(), and nxsem_destroy() is undefined.
+ *   nxsem_post(), and nxsem_destroy() is undefined.
  *
  * Parameters:
  *   sem - Semaphore to be initialized
diff --git a/mm/iob/iob_alloc.c b/mm/iob/iob_alloc.c
index aaa2e1f880..00d5122032 100644
--- a/mm/iob/iob_alloc.c
+++ b/mm/iob/iob_alloc.c
@@ -140,11 +140,9 @@ static FAR struct iob_s *iob_allocwait(bool throttled)
        * list.
        */
 
-      ret = sem_wait(sem);
+      ret = nxsem_wait(sem);
       if (ret < 0)
         {
-          int errcode = get_errno();
-
           /* EINTR is not an error!  EINTR simply means that we were
            * awakened by a signal and we should try again.
            *
@@ -154,18 +152,11 @@ static FAR struct iob_s *iob_allocwait(bool throttled)
            * should be returned.
            */
 
-          if (errcode == EINTR)
+          if (ret == -EINTR)
             {
               /* Force a success indication so that we will continue looping. */
 
-              ret = 0;
-            }
-          else
-            {
-              /* Stop the loop and return a error */
-
-              DEBUGASSERT(errcode > 0);
-              ret = -errcode;
+              ret = OK;
             }
         }
       else
@@ -279,7 +270,7 @@ FAR struct iob_s *iob_tryalloc(bool throttled)
           g_iob_freelist = iob->io_flink;
 
           /* Take a semaphore count.  Note that we cannot do this in
-           * in the orthodox way by calling sem_wait() or sem_trywait()
+           * in the orthodox way by calling nxsem_wait() or sem_trywait()
            * because this function may be called from an interrupt
            * handler. Fortunately we know at at least one free buffer
            * so a simple decrement is all that is needed.
diff --git a/mm/iob/iob_alloc_qentry.c b/mm/iob/iob_alloc_qentry.c
index 4d248f22a1..4910b299ec 100644
--- a/mm/iob/iob_alloc_qentry.c
+++ b/mm/iob/iob_alloc_qentry.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * mm/iob/iob_alloc_qentry.c
  *
- *   Copyright (C) 2014, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -130,11 +130,9 @@ static FAR struct iob_qentry_s *iob_allocwait_qentry(void)
        * semaphore count will be incremented.
        */
 
-      ret = sem_wait(&g_qentry_sem);
+      ret = nxsem_wait(&g_qentry_sem);
       if (ret < 0)
         {
-          int errcode = get_errno();
-
           /* EINTR is not an error!  EINTR simply means that we were
            * awakened by a signal and we should try again.
            *
@@ -144,20 +142,11 @@ static FAR struct iob_qentry_s *iob_allocwait_qentry(void)
            * the error should be returned.
            */
 
-          if (errcode == EINTR)
+          if (ret == -EINTR)
             {
-              /* Force a success indication so that we will continue
-               * looping.
-               */
+              /* Force a success indication so that we will continue looping. */
 
-              ret = 0;
-            }
-          else
-            {
-              /* Stop the loop and return a error */
-
-              DEBUGASSERT(errcode > 0);
-              ret = -errcode;
+              ret = OK;
             }
         }
       else
@@ -256,7 +245,7 @@ FAR struct iob_qentry_s *iob_tryalloc_qentry(void)
       g_iob_freeqlist = iobq->qe_flink;
 
       /* Take a semaphore count.  Note that we cannot do this in
-       * in the orthodox way by calling sem_wait() or sem_trywait()
+       * in the orthodox way by calling nxsem_wait() or sem_trywait()
        * because this function may be called from an interrupt
        * handler. Fortunately we know at at least one free buffer
        * so a simple decrement is all that is needed.
diff --git a/mm/iob/iob_initialize.c b/mm/iob/iob_initialize.c
index d9ef23154c..ad88812d5e 100644
--- a/mm/iob/iob_initialize.c
+++ b/mm/iob/iob_initialize.c
@@ -40,8 +40,8 @@
 #include <nuttx/config.h>
 
 #include <stdbool.h>
-#include <semaphore.h>
 
+#include <nuttx/semaphore.h>
 #include <nuttx/mm/iob.h>
 
 #include "iob.h"
diff --git a/mm/mm_gran/mm_grancritical.c b/mm/mm_gran/mm_grancritical.c
index 1ace35fdea..f009e902a1 100644
--- a/mm/mm_gran/mm_grancritical.c
+++ b/mm/mm_gran/mm_grancritical.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * mm/mm_gran/mm_grancritical.c
  *
- *   Copyright (C) 2012, 2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012, 2016-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -79,13 +79,13 @@ void gran_enter_critical(FAR struct gran_s *priv)
 
   do
     {
-      ret = sem_wait(&priv->exclsem);
+      ret = nxsem_wait(&priv->exclsem);
       if (ret < 0)
         {
-          DEBUGASSERT(errno == EINTR);
+          DEBUGASSERT(ret == -EINTR);
         }
     }
-  while (ret < 0);
+  while (ret == -EINTR);
 #endif
 }
 
diff --git a/mm/mm_heap/mm_sem.c b/mm/mm_heap/mm_sem.c
index 81e16d3959..e6ac5d0080 100644
--- a/mm/mm_heap/mm_sem.c
+++ b/mm/mm_heap/mm_sem.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * mm/mm_heap/mm_sem.c
  *
- *   Copyright (C) 2007-2009, 2013 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2007-2009, 2013, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -158,19 +158,26 @@ void mm_takesemaphore(FAR struct mm_heap_s *heap)
     }
   else
     {
+      int ret;
+
       /* Take the semaphore (perhaps waiting) */
 
       mseminfo("PID=%d taking\n", my_pid);
-      while (sem_wait(&heap->mm_semaphore) != 0)
+      do
         {
-          /* The only case that an error should occur here is if
-           * the wait was awakened by a signal.
+          ret = nxsem_wait(&heap->mm_semaphore);
+
+          /* The only case that an error should occur here is if the wait
+           * was awakened by a signal.
            */
 
-          ASSERT(errno == EINTR);
+          DEBUGASSERT(ret == OK || ret == -EINTR);
         }
+      while (ret == -EINTR);
 
-      /* We have it.  Claim the stake and return */
+      /* We have it (or some awful, unexpected error occurred).  Claim
+       * the semaphore and return.
+       */
 
       heap->mm_holder      = my_pid;
       heap->mm_counts_held = 1;
diff --git a/mm/shm/shmat.c b/mm/shm/shmat.c
index 75ac446a35..befd39a92d 100644
--- a/mm/shm/shmat.c
+++ b/mm/shm/shmat.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * mm/shm/shmat.c
  *
- *   Copyright (C) 2014 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -133,11 +133,11 @@ FAR void *shmat(int shmid, FAR const void *shmaddr, int shmflg)
 
   /* Get exclusive access to the region data structure */
 
-  ret = sem_wait(&region->sr_sem);
+  ret = nxsem_wait(&region->sr_sem);
   if (ret < 0)
     {
-      shmerr("ERROR: sem_wait failed: %d\n", ret);
-      goto errout;
+      shmerr("ERROR: nxsem_wait failed: %d\n", ret);
+      goto errout_with_ret;
     }
 
   /* Set aside a virtual address space to span this physical region */
@@ -191,10 +191,12 @@ FAR void *shmat(int shmid, FAR const void *shmaddr, int shmflg)
 errout_with_vaddr:
   gran_free(group->tg_shm.gs_handle, (FAR void *)vaddr,
             region->sr_ds.shm_segsz);
+
 errout_with_semaphore:
   nxsem_post(&region->sr_sem);
+
+errout_with_ret:
   set_errno(-ret);
-errout:
   return (FAR void *)ERROR;
 }
 
diff --git a/mm/shm/shmctl.c b/mm/shm/shmctl.c
index d5ca4969e2..34e4dfeeff 100644
--- a/mm/shm/shmctl.c
+++ b/mm/shm/shmctl.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * mm/shm/shmctl.c
  *
- *   Copyright (C) 2014 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -131,11 +131,11 @@ int shmctl(int shmid, int cmd, struct shmid_ds *buf)
 
   /* Get exclusive access to the region data structure */
 
-  ret = sem_wait(&region->sr_sem);
+  ret = nxsem_wait(&region->sr_sem);
   if (ret < 0)
     {
-      shmerr("ERROR: sem_wait failed: %d\n", ret);
-      return ret;
+      shmerr("ERROR: nxsem_wait failed: %d\n", ret);
+      goto errout_with_ret;
     }
 
   /* Handle the request according to the received cmd */
@@ -213,6 +213,8 @@ int shmctl(int shmid, int cmd, struct shmid_ds *buf)
 
 errout_with_semaphore:
   nxsem_post(&region->sr_sem);
+
+errout_with_ret:
   set_errno(-ret);
   return ERROR;
 }
diff --git a/mm/shm/shmdt.c b/mm/shm/shmdt.c
index a96008be32..f51f719509 100644
--- a/mm/shm/shmdt.c
+++ b/mm/shm/shmdt.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * mm/shm/shmdt.c
  *
- *   Copyright (C) 2014 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -118,11 +118,11 @@ int shmdt(FAR const void *shmaddr)
 
   /* Get exclusive access to the region data structure */
 
-  ret = sem_wait(&region->sr_sem);
+  ret = nxsem_wait(&region->sr_sem);
   if (ret < 0)
     {
-      shmerr("ERROR: sem_wait failed: %d\n", ret);
-      goto errout;
+      shmerr("ERROR: nxsem_wait failed: %d\n", ret);
+      goto errout_with_errno;
     }
 
   /* Free the virtual address space */
@@ -188,7 +188,6 @@ int shmdt(FAR const void *shmaddr)
 
 errout_with_errno:
   set_errno(-ret);
-errout:
   return ERROR;
 }
 
diff --git a/mm/shm/shmget.c b/mm/shm/shmget.c
index 5c2317a748..682b4707ed 100644
--- a/mm/shm/shmget.c
+++ b/mm/shm/shmget.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * mm/shm/shmget.c
  *
- *   Copyright (C) 2014 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -381,99 +381,101 @@ int shmget(key_t key, size_t size, int shmflg)
 
   /* Get exclusive access to the global list of shared memory regions */
 
-  ret = sem_wait(&g_shminfo.si_sem);
-  if (ret >= 0)
+  ret = nxsem_wait(&g_shminfo.si_sem);
+  if (ret < 0)
     {
-      /* Find the requested memory region */
+      goto errout;
+    }
 
-      ret = shm_find(key);
-      if (ret < 0)
+  /* Find the requested memory region */
+
+  ret = shm_find(key);
+  if (ret < 0)
+    {
+      /* The memory region does not exist.. create it if IPC_CREAT is
+       * included in the shmflags.
+       */
+
+      if ((shmflg & IPC_CREAT) != 0)
         {
-          /* The memory region does not exist.. create it if IPC_CREAT is
-           * included in the shmflags.
+          /* Create the memory region */
+
+          ret = shm_create(key, size, shmflg);
+          if (ret < 0)
+            {
+              shmerr("ERROR: shm_create failed: %d\n", ret);
+              goto errout_with_semaphore;
+            }
+
+          /* Return the shared memory ID */
+
+          shmid = ret;
+        }
+      else
+        {
+          /* Fail with ENOENT */
+
+          goto errout_with_semaphore;
+        }
+    }
+
+  /* The region exists */
+
+  else
+    {
+      /* Remember the shared memory ID */
+
+      shmid = ret;
+
+      /* Is the region big enough for the request? */
+
+      region = &g_shminfo.si_region[shmid];
+      if (region->sr_ds.shm_segsz < size)
+        {
+          /* We we asked to create the region?  If so we can just
+           * extend it.
+           *
+           * REVISIT: We should check the mode bits of the regions
+           * first
            */
 
           if ((shmflg & IPC_CREAT) != 0)
             {
-              /* Create the memory region */
+              /* Extend the region */
 
-              ret = shm_create(key, size, shmflg);
+              ret = shm_extend(shmid, size);
               if (ret < 0)
                 {
                   shmerr("ERROR: shm_create failed: %d\n", ret);
                   goto errout_with_semaphore;
                 }
-
-              /* Return the shared memory ID */
-
-              shmid = ret;
             }
           else
             {
-              /* Fail with ENOENT */
+              /* Fail with EINVAL */
 
+              ret = -EINVAL;
               goto errout_with_semaphore;
             }
         }
 
-      /* The region exists */
+      /* The region is already big enough or else we successfully
+       * extended the size of the region.  If the region was previously
+       * deleted, but waiting for processes to detach from the region,
+       * then it is no longer deleted.
+       */
 
-      else
-        {
-          /* Remember the shared memory ID */
-
-          shmid = ret;
-
-          /* Is the region big enough for the request? */
-
-          region = &g_shminfo.si_region[shmid];
-          if (region->sr_ds.shm_segsz < size)
-            {
-              /* We we asked to create the region?  If so we can just
-               * extend it.
-               *
-               * REVISIT: We should check the mode bits of the regions
-               * first
-               */
-
-              if ((shmflg & IPC_CREAT) != 0)
-                {
-                  /* Extend the region */
-
-                  ret = shm_extend(shmid, size);
-                  if (ret < 0)
-                    {
-                      shmerr("ERROR: shm_create failed: %d\n", ret);
-                      goto errout_with_semaphore;
-                    }
-                }
-              else
-                {
-                  /* Fail with EINVAL */
-
-                  ret = -EINVAL;
-                  goto errout_with_semaphore;
-                }
-            }
-
-          /* The region is already big enough or else we successfully
-           * extended the size of the region.  If the region was previously
-           * deleted, but waiting for processes to detach from the region,
-           * then it is no longer deleted.
-           */
-
-          region->sr_flags = SRFLAG_INUSE;
-        }
-
-      /* Release our lock on the shared memory region list */
-
-      nxsem_post(&g_shminfo.si_sem);
+      region->sr_flags = SRFLAG_INUSE;
     }
 
+  /* Release our lock on the shared memory region list */
+
+  nxsem_post(&g_shminfo.si_sem);
   return shmid;
 
 errout_with_semaphore:
   nxsem_post(&g_shminfo.si_sem);
+
 errout:
   set_errno(-ret);
   return ERROR;
diff --git a/net/local/local_accept.c b/net/local/local_accept.c
index e34ca45abc..7b440dd534 100644
--- a/net/local/local_accept.c
+++ b/net/local/local_accept.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * net/local/local_accept.c
  *
- *   Copyright (C) 2015 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -69,12 +69,11 @@ static int local_waitlisten(FAR struct local_conn_s *server)
     {
       /* No.. wait for a connection or a signal */
 
-      ret = sem_wait(&server->lc_waitsem);
+      ret = nxsem_wait(&server->lc_waitsem);
       if (ret < 0)
         {
-          int errval = get_errno();
-          DEBUGASSERT(errval == EINTR);
-          return -errval;
+          DEBUGASSERT(ret == -EINTR);
+          return ret;
         }
     }
 
diff --git a/net/local/local_connect.c b/net/local/local_connect.c
index 2f57f52982..ece5678a84 100644
--- a/net/local/local_connect.c
+++ b/net/local/local_connect.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * net/local/local_connnect.c
  *
- *   Copyright (C) 2015-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2015-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -90,16 +90,21 @@ static int32_t local_generate_instance_id(void)
 
 static inline void _local_semtake(sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if
-       * the wait was awakened by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      DEBUGASSERT(get_errno() == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 #define _local_semgive(sem) nxsem_post(sem)
diff --git a/net/route/net_cacheroute.c b/net/route/net_cacheroute.c
index eb8956be1e..6c601ca5cf 100644
--- a/net/route/net_cacheroute.c
+++ b/net/route/net_cacheroute.c
@@ -177,31 +177,8 @@ static sem_t g_ipv6_cachelock;
  *
  ****************************************************************************/
 
-#ifdef CONFIG_ROUTE_IPv4_CACHEROUTE
-static int net_lock_ipv4_cache(void)
-{
-  int ret = sem_wait(&g_ipv4_cachelock);
-  if (ret < 0)
-    {
-      ret = -get_errno();
-    }
-
-  return ret;
-}
-#endif
-
-#ifdef CONFIG_ROUTE_IPv6_CACHEROUTE
-static int net_lock_ipv6_cache(void)
-{
-  int ret = sem_wait(&g_ipv6_cachelock);
-  if (ret < 0)
-    {
-      ret = -get_errno();
-    }
-
-  return ret;
-}
-#endif
+#define net_lock_ipv4_cache() mxsem_wait(&g_ipv4_cachelock);
+#define net_lock_ipv6_cache() mxsem_wait(&g_ipv6_cachelock);
 
 /****************************************************************************
  * Name: net_unlock_ipv4_cache and net_unlock_ipv6_cache
diff --git a/net/route/net_fileroute.c b/net/route/net_fileroute.c
index a4f1f2a939..36a0e486b3 100644
--- a/net/route/net_fileroute.c
+++ b/net/route/net_fileroute.c
@@ -674,12 +674,10 @@ int net_lockroute_ipv4(void)
     {
       /* No.. wait to get the lock */
 
-      ret = sem_wait(&g_ipv4_exclsem);
+      ret = nxsem_wait(&g_ipv4_exclsem);
       if (ret < 0)
         {
-          int errcode = get_errno();
-          nerr("ERROR: sem_wait() failed: %d\n", errcode);
-          ret = -errcode;
+          nerr("ERROR: nxsem_wait() failed: %d\n", ret);
         }
       else
         {
@@ -715,12 +713,10 @@ int net_lockroute_ipv6(void)
     {
       /* No.. wait to get the lock */
 
-      ret = sem_wait(&g_ipv6_exclsem);
+      ret = nxsem_wait(&g_ipv6_exclsem);
       if (ret < 0)
         {
-          int errcode = get_errno();
-          nerr("ERROR: sem_wait() failed: %d\n", errcode);
-          ret = -errcode;
+          nerr("ERROR: nxsem_wait() failed: %d\n", errcode);
         }
       else
         {
diff --git a/net/socket/net_vfcntl.c b/net/socket/net_vfcntl.c
index 20cd63e012..3833908af3 100644
--- a/net/socket/net_vfcntl.c
+++ b/net/socket/net_vfcntl.c
@@ -78,7 +78,7 @@
 int net_vfcntl(int sockfd, int cmd, va_list ap)
 {
   FAR struct socket *psock = sockfd_socket(sockfd);
-  int ret;
+  int ret = -EINVAL;
 
   ninfo("sockfd=%d cmd=%d\n", sockfd, cmd);
 
@@ -249,7 +249,6 @@ int net_vfcntl(int sockfd, int cmd, va_list ap)
          break;
 
       default:
-         ret = -EINVAL;
          break;
     }
 
diff --git a/net/tcp/tcp_wrbuffer.c b/net/tcp/tcp_wrbuffer.c
index 33be8fe809..6553d34f20 100644
--- a/net/tcp/tcp_wrbuffer.c
+++ b/net/tcp/tcp_wrbuffer.c
@@ -49,11 +49,11 @@
 #endif
 
 #include <queue.h>
-#include <semaphore.h>
 #include <string.h>
 #include <assert.h>
 #include <debug.h>
 
+#include <nuttx/semaphore.h>
 #include <nuttx/net/net.h>
 #include <nuttx/mm/iob.h>
 
diff --git a/net/udp/udp_conn.c b/net/udp/udp_conn.c
index e998ae9b37..97037c444f 100644
--- a/net/udp/udp_conn.c
+++ b/net/udp/udp_conn.c
@@ -45,7 +45,6 @@
 
 #include <stdint.h>
 #include <string.h>
-#include <semaphore.h>
 #include <assert.h>
 #include <errno.h>
 #include <debug.h>
@@ -54,6 +53,7 @@
 
 #include <arch/irq.h>
 
+#include <nuttx/semaphore.h>
 #include <nuttx/net/netconfig.h>
 #include <nuttx/net/net.h>
 #include <nuttx/net/netdev.h>
diff --git a/net/usrsock/usrsock_dev.c b/net/usrsock/usrsock_dev.c
index 58a5767944..0667297414 100644
--- a/net/usrsock/usrsock_dev.c
+++ b/net/usrsock/usrsock_dev.c
@@ -299,16 +299,21 @@ static uint8_t usrsockdev_get_xid(FAR struct usrsock_conn_s *conn)
 
 static void usrsockdev_semtake(FAR sem_t *sem)
 {
-  /* Take the semaphore (perhaps waiting) */
+  int ret;
 
-  while (sem_wait(sem) != 0)
+  do
     {
-      /* The only case that an error should occur here is if
-       * the wait was awakened by a signal.
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
        */
 
-      DEBUGASSERT(*get_errno_ptr() == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 static void usrsockdev_semgive(FAR sem_t *sem)
diff --git a/net/utils/net_lock.c b/net/utils/net_lock.c
index 487c629d2f..6434dcc2c4 100644
--- a/net/utils/net_lock.c
+++ b/net/utils/net_lock.c
@@ -80,14 +80,21 @@ static unsigned int g_count   = 0;
 
 static void _net_takesem(void)
 {
-  while (sem_wait(&g_netlock) != 0)
+  int ret;
+
+  do
     {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&g_netlock);
+
       /* The only case that an error should occur here is if the wait was
        * awakened by a signal.
        */
 
-      DEBUGASSERT(get_errno() == EINTR);
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
@@ -229,17 +236,7 @@ int net_timedwait(sem_t *sem, FAR const struct timespec *abstime)
         {
           /* Wait as long as necessary to get the lock */
 
-          ret = sem_wait(sem);
-        }
-
-      /* Check for errors from sem_wait() (should only be EINTR)
-       * REVISIT:  errno really should not be used within the OS
-       */
-
-      if (ret < 0)
-        {
-          ret = -get_errno();
-          DEBUGASSERT(ret < 0);
+          ret = nxsem_wait(sem);
         }
 
       /* Recover the network lock at the proper count */
@@ -250,17 +247,7 @@ int net_timedwait(sem_t *sem, FAR const struct timespec *abstime)
     }
   else
     {
-      ret = sem_wait(sem);
-
-      /* Check for errors from sem_wait() (should only be EINTR)
-       * REVISIT:  errno really should not be used within the OS
-       */
-
-      if (ret < 0)
-        {
-          ret = -get_errno();
-          DEBUGASSERT(ret < 0);
-        }
+      ret = nxsem_wait(sem);
     }
 
 
diff --git a/sched/pthread/pthread.h b/sched/pthread/pthread.h
index 96fb66b8d9..b4d1ece0d8 100644
--- a/sched/pthread/pthread.h
+++ b/sched/pthread/pthread.h
@@ -125,14 +125,6 @@ void pthread_mutex_inconsistent(FAR struct pthread_tcb_s *tcb);
 #  define pthread_mutex_give(m)    pthread_sem_give(&(m)->sem)
 #endif
 
-#if defined(CONFIG_CANCELLATION_POINTS) && !defined(CONFIG_PTHREAD_MUTEX_UNSAFE)
-uint16_t pthread_disable_cancel(void);
-void pthread_enable_cancel(uint16_t oldstate);
-#else
-#  define pthread_disable_cancel() (0)
-#  define pthread_enable_cancel(s) UNUSED(s)
-#endif
-
 #ifdef CONFIG_PTHREAD_MUTEX_TYPES
 int pthread_mutexattr_verifytype(int type);
 #endif
diff --git a/sched/pthread/pthread_condtimedwait.c b/sched/pthread/pthread_condtimedwait.c
index 98521665fd..ed85e17046 100644
--- a/sched/pthread/pthread_condtimedwait.c
+++ b/sched/pthread/pthread_condtimedwait.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * sched/pthread/pthread_condtimedwait.c
  *
- *   Copyright (C) 2007-2009, 2013-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2007-2009, 2013-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -168,7 +168,6 @@ int pthread_cond_timedwait(FAR pthread_cond_t *cond, FAR pthread_mutex_t *mutex,
 {
   FAR struct tcb_s *rtcb = this_task();
   irqstate_t flags;
-  uint16_t oldstate;
   ssystime_t ticks;
   int mypid = (int)getpid();
   int ret = OK;
@@ -283,25 +282,25 @@ int pthread_cond_timedwait(FAR pthread_cond_t *cond, FAR pthread_mutex_t *mutex,
                        * are started atomically.
                        */
 
-                      status = sem_wait((FAR sem_t *)&cond->sem);
+                      status = nxsem_wait((FAR sem_t *)&cond->sem);
 
                       /* Did we get the condition semaphore. */
 
-                      if (status != OK)
+                      if (status < 0)
                         {
-                          /* NO.. Handle the special case where the semaphore wait was
-                           * awakened by the receipt of a signal -- presumably the
-                           * signal posted by pthread_condtimedout().
+                          /* NO.. Handle the special case where the semaphore
+                           * wait was awakened by the receipt of a signal --
+                           * presumably the signal posted by pthread_condtimedout().
                            */
 
-                          if (get_errno() == EINTR)
+                          if (status == -EINTR)
                             {
                               serr("ERROR: Timedout!\n");
                               ret = ETIMEDOUT;
                             }
                           else
                             {
-                              ret = EINVAL;
+                              ret = status;
                             }
                         }
 
@@ -318,10 +317,7 @@ int pthread_cond_timedwait(FAR pthread_cond_t *cond, FAR pthread_mutex_t *mutex,
 
                   sinfo("Re-locking...\n");
 
-                  oldstate = pthread_disable_cancel();
                   status = pthread_mutex_take(mutex, false);
-                  pthread_enable_cancel(oldstate);
-
                   if (status == OK)
                     {
                       mutex->pid = mypid;
diff --git a/sched/pthread/pthread_condwait.c b/sched/pthread/pthread_condwait.c
index 8d47d20673..b3716da0a6 100644
--- a/sched/pthread/pthread_condwait.c
+++ b/sched/pthread/pthread_condwait.c
@@ -95,8 +95,6 @@ int pthread_cond_wait(FAR pthread_cond_t *cond, FAR pthread_mutex_t *mutex)
     }
   else
     {
-      uint16_t oldstate;
-
       /* Give up the mutex */
 
       sinfo("Give up mutex / take cond\n");
@@ -119,17 +117,14 @@ int pthread_cond_wait(FAR pthread_cond_t *cond, FAR pthread_mutex_t *mutex)
 
       /* Reacquire the mutex.
        *
-       * When cancellation points are enabled, we need to
-       * hold the mutex when the pthread is canceled and
-       * cleanup handlers, if any, are entered.
+       * When cancellation points are enabled, we need to hold the mutex
+       * when the pthread is canceled and cleanup handlers, if any, are
+       * entered.
        */
 
       sinfo("Reacquire mutex...\n");
 
-      oldstate = pthread_disable_cancel();
       status = pthread_mutex_take(mutex, false);
-      pthread_enable_cancel(oldstate);
-
       if (ret == OK)
         {
           /* Report the first failure that occurs */
diff --git a/sched/pthread/pthread_initialize.c b/sched/pthread/pthread_initialize.c
index b7297af58a..f0f4b5dd35 100644
--- a/sched/pthread/pthread_initialize.c
+++ b/sched/pthread/pthread_initialize.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * sched/pthread/pthread_initialize.c
  *
- *   Copyright (C) 2007-2010, 2013 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2007-2010, 2013, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -96,35 +96,46 @@ void pthread_initialize(void)
 
 int pthread_sem_take(sem_t *sem, bool intr)
 {
+  int ret;
+
   /* Verify input parameters */
 
   DEBUGASSERT(sem != NULL);
   if (sem != NULL)
     {
-      /* Take the semaphore */
-
-      while (sem_wait(sem) != OK)
+      do
         {
-          int errcode = get_errno();
+          /* Take the semaphore (perhaps waiting) */
 
-          /* Handle the special case where the semaphore wait was
-           * awakened by the receipt of a signal.
-           */
-
-          if (intr || errcode != EINTR)
+          ret = nxsem_wait(sem);
+          if (ret < 0)
             {
-              return errcode;
+              /* The only case that an error should occur here is if the wait
+               * was awakened by a signal.
+               */
+
+              DEBUGASSERT(ret == -EINTR);
+
+              /* When the signal is received, should we errout? Or should we
+               * just continue waiting until we have the semaphore?
+               */
+
+              if (intr)
+                {
+                  return -ret;
+                }
             }
         }
+      while (ret == -EINTR);
+
+      /* We have the semaphore (or some awful, unexpected error has
+       * occurred).
+       */
 
       return OK;
     }
-  else
-    {
-      /* NULL semaphore pointer! */
 
-      return EINVAL;
-    }
+  return EINVAL;
 }
 
 #ifdef CONFIG_PTHREAD_MUTEX_UNSAFE
diff --git a/sched/pthread/pthread_mutex.c b/sched/pthread/pthread_mutex.c
index c485c9dce3..d9792ae07c 100644
--- a/sched/pthread/pthread_mutex.c
+++ b/sched/pthread/pthread_mutex.c
@@ -61,7 +61,7 @@
  *   Add the mutex to the list of mutexes held by this pthread.
  *
  * Parameters:
- *  mutex - The mux to be locked
+ *  mutex - The mutex to be locked
  *
  * Return Value:
  *   None
@@ -104,7 +104,7 @@ static void pthread_mutex_add(FAR struct pthread_mutex_s *mutex)
  *   Remove the mutex to the list of mutexes held by this pthread.
  *
  * Parameters:
- *  mutex - The mux to be locked
+ *  mutex - The mutex to be locked
  *
  * Return Value:
  *   None
@@ -296,7 +296,7 @@ int pthread_mutex_trytake(FAR struct pthread_mutex_s *mutex)
  *   mutexes held by this thread.
  *
  * Parameters:
- *  mutex - The mux to be unlocked
+ *  mutex - The mutex to be unlocked
  *
  * Return Value:
  *   0 on success or an errno value on failure.
@@ -323,71 +323,3 @@ int pthread_mutex_give(FAR struct pthread_mutex_s *mutex)
 
   return ret;
 }
-
-/****************************************************************************
- * Name: pthread_disable_cancel() and pthread_enable_cancel()
- *
- * Description:
- *   Temporarily disable cancellation and return old cancel state, which
- *   can later be restored.  This is useful when a cancellation point
- *   function is called from within the OS by a non-cancellation point:
- *   In certain such cases, we need to defer the cancellation to prevent
- *   bad things from happening.
- *
- * Parameters:
- *   saved cancel flags for pthread_enable_cancel()
- *
- * Return Value:
- *   old cancel flags for pthread_disable_cancel()
- *
- ****************************************************************************/
-
-#ifdef CONFIG_CANCELLATION_POINTS
-uint16_t pthread_disable_cancel(void)
-{
-  FAR struct tcb_s *tcb = this_task();
-  irqstate_t flags;
-  uint16_t old;
-
-  /* We need perform the following operations from within a critical section
-   * because it can compete with interrupt level activity.
-   */
-
-  flags = enter_critical_section();
-  old = tcb->flags & (TCB_FLAG_CANCEL_PENDING | TCB_FLAG_NONCANCELABLE);
-  tcb->flags &= ~(TCB_FLAG_CANCEL_PENDING | TCB_FLAG_NONCANCELABLE);
-  leave_critical_section(flags);
-  return old;
-}
-
-void pthread_enable_cancel(uint16_t cancelflags)
-{
-  FAR struct tcb_s *tcb = this_task();
-  irqstate_t flags;
-
-  /* We need perform the following operations from within a critical section
-   * because it can compete with interrupt level activity.
-   */
-
-  flags = enter_critical_section();
-  tcb->flags |= cancelflags;
-
-  /* What should we do if there is a pending cancellation?
-   *
-   * If the thread is executing with deferred cancellation, we need do
-   * nothing more; the cancellation cannot occur until the next
-   * cancellation point.
-   *
-   * However, if the thread is executing in asynchronous cancellation mode,
-   * then we need to terminate now by simply calling pthread_exit().
-   */
-
-  if ((tcb->flags & TCB_FLAG_CANCEL_DEFERRED) == 0 &&
-      (tcb->flags & TCB_FLAG_CANCEL_PENDING) != 0)
-    {
-      pthread_exit(NULL);
-    }
-
-  leave_critical_section(flags);
-}
-#endif /* CONFIG_CANCELLATION_POINTS */
diff --git a/sched/sched/sched_waitpid.c b/sched/sched/sched_waitpid.c
index b60f6d526c..95bff94dac 100644
--- a/sched/sched/sched_waitpid.c
+++ b/sched/sched/sched_waitpid.c
@@ -253,12 +253,12 @@ pid_t waitpid(pid_t pid, int *stat_loc, int options)
     {
       /* Wait if necessary for status to become available */
 
-      ret = sem_wait(&group->tg_exitsem);
+      ret = nxsem_wait(&group->tg_exitsem);
       group_delwaiter(group);
 
       if (ret < 0)
         {
-          /* Unlock pre-emption and return the ERROR (sem_wait has already set
+          /* Unlock pre-emption and return the ERROR (nxsem_wait has already set
            * the errno).  Handle the awkward case of whether or not we need to
            * nullify the stat_loc value.
            */
@@ -268,7 +268,8 @@ pid_t waitpid(pid_t pid, int *stat_loc, int options)
               group->tg_statloc = NULL;
             }
 
-          goto errout;
+          errcode = -ret;
+          goto errout_with_errno;
         }
     }
 
@@ -280,7 +281,7 @@ pid_t waitpid(pid_t pid, int *stat_loc, int options)
 
 errout_with_errno:
   set_errno(errcode);
-errout:
+
   leave_cancellation_point();
   sched_unlock();
   return ERROR;
diff --git a/sched/semaphore/sem_holder.c b/sched/semaphore/sem_holder.c
index dca9e98b78..cc7c0c08a7 100644
--- a/sched/semaphore/sem_holder.c
+++ b/sched/semaphore/sem_holder.c
@@ -925,7 +925,7 @@ void nxsem_destroyholder(FAR sem_t *sem)
  * Name: nxsem_addholder_tcb
  *
  * Description:
- *   Called from sem_wait() when the calling thread obtains the semaphore;
+ *   Called from nxsem_wait() when the calling thread obtains the semaphore;
  *   Called from sem_post() when the waiting thread obtains the semaphore.
  *
  * Parameters:
@@ -970,7 +970,7 @@ void nxsem_addholder_tcb(FAR struct tcb_s *htcb, FAR sem_t *sem)
  * Name: nxsem_addholder
  *
  * Description:
- *   Called from sem_wait() when the calling thread obtains the semaphore
+ *   Called from nxsem_wait() when the calling thread obtains the semaphore
  *
  * Parameters:
  *   sem - A reference to the incremented semaphore
diff --git a/sched/semaphore/sem_post.c b/sched/semaphore/sem_post.c
index 248a0282d1..08a399b916 100644
--- a/sched/semaphore/sem_post.c
+++ b/sched/semaphore/sem_post.c
@@ -69,7 +69,7 @@
  *
  *   If the value of the semaphore resulting from this operation is zero,
  *   then one of the tasks blocked waiting for the semaphore shall be
- *   allowed to return successfully from its call to sem_wait().
+ *   allowed to return successfully from its call to nxsem_wait().
  *
  * Parameters:
  *   sem - Semaphore descriptor
@@ -200,7 +200,7 @@ int nxsem_post(FAR sem_t *sem)
  *
  *   If the value of the semaphore resulting from this operation is zero,
  *   then one of the tasks blocked waiting for the semaphore shall be
- *   allowed to return successfully from its call to sem_wait().
+ *   allowed to return successfully from its call to nxsem_wait().
  *
  * Parameters:
  *   sem - Semaphore descriptor
diff --git a/sched/semaphore/sem_setprotocol.c b/sched/semaphore/sem_setprotocol.c
index 164fd919e3..f4b202b22b 100644
--- a/sched/semaphore/sem_setprotocol.c
+++ b/sched/semaphore/sem_setprotocol.c
@@ -134,7 +134,7 @@ int nxsem_setprotocol(FAR sem_t *sem, int protocol)
  *
  *      TASK A                 TASK B
  *      sem_init(sem, 0, 0);
- *      sem_wait(sem);
+ *      nxsem_wait(sem);
  *                             sem_post(sem);
  *      Awakens as holder
  *
diff --git a/sched/semaphore/sem_tickwait.c b/sched/semaphore/sem_tickwait.c
index 8904ad92ce..daf07ade51 100644
--- a/sched/semaphore/sem_tickwait.c
+++ b/sched/semaphore/sem_tickwait.c
@@ -154,12 +154,9 @@ int nxsem_tickwait(FAR sem_t *sem, systime_t start, uint32_t delay)
 
   /* Now perform the blocking wait */
 
-  ret = sem_wait(sem);
+  ret = nxsem_wait(sem);
   if (ret < 0)
     {
-      /* Return the errno from sem_wait() */
-
-      ret = -get_errno();
       goto errout_with_irqdisabled;
     }
 
diff --git a/sched/semaphore/sem_timedwait.c b/sched/semaphore/sem_timedwait.c
index f3348b5929..6d19a77e08 100644
--- a/sched/semaphore/sem_timedwait.c
+++ b/sched/semaphore/sem_timedwait.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * sched/semaphore/sem_timedwait.c
  *
- *   Copyright (C) 2011, 2013-2016 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011, 2013-2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -190,20 +190,17 @@ int sem_timedwait(FAR sem_t *sem, FAR const struct timespec *abstime)
 
   /* Now perform the blocking wait */
 
-  ret = sem_wait(sem);
-  if (ret < 0)
-    {
-      /* sem_wait() failed.  Save the errno value */
-
-      errcode = get_errno();
-    }
+  ret = nxsem_wait(sem);
 
   /* Stop the watchdog timer */
 
   wd_cancel(rtcb->waitdog);
 
-  if (errcode != OK)
+  if (ret < 0)
     {
+      /* nxsem_wait() failed.  Save the errno value */
+
+      errcode = -ret;
       goto errout_with_irqdisabled;
     }
 
diff --git a/sched/semaphore/sem_wait.c b/sched/semaphore/sem_wait.c
index eaa2c950ad..5b2b8ceb5d 100644
--- a/sched/semaphore/sem_wait.c
+++ b/sched/semaphore/sem_wait.c
@@ -56,32 +56,38 @@
  ****************************************************************************/
 
 /****************************************************************************
- * Name: sem_wait
+ * Name: nxsem_wait
  *
  * Description:
  *   This function attempts to lock the semaphore referenced by 'sem'.  If
  *   the semaphore value is (<=) zero, then the calling task will not return
  *   until it successfully acquires the lock.
  *
+ *   This is an internal OS interface.  It is functionally equivalent to
+ *   sem_wait except that:
+ *
+ *   - It is not a cancellaction point, and
+ *   - It does not modify the errno value.
+ *
  * Parameters:
  *   sem - Semaphore descriptor.
  *
  * Return Value:
- *   0 (OK), or -1 (ERROR) is unsuccessful
- *   If this function returns -1 (ERROR), then the cause of the failure will
- *   be reported in 'errno' as:
+ *   This is an internal OS interface and should not be used by applications.
+ *   It follows the NuttX internal error return policy:  Zero (OK) is
+ *   returned on success.  A negated errno value is returned on failure.
+ *   Possible returned errors:
+ *
  *   - EINVAL:  Invalid attempt to get the semaphore
  *   - EINTR:   The wait was interrupted by the receipt of a signal.
  *
- * Assumptions:
- *
  ****************************************************************************/
 
-int sem_wait(FAR sem_t *sem)
+int nxsem_wait(FAR sem_t *sem)
 {
   FAR struct tcb_s *rtcb = this_task();
   irqstate_t flags;
-  int ret  = ERROR;
+  int ret = -EINVAL;
 
   /* This API should not be called from interrupt handlers */
 
@@ -94,22 +100,6 @@ int sem_wait(FAR sem_t *sem)
 
   flags = enter_critical_section();
 
-  /* sem_wait() is a cancellation point */
-
-  if (enter_cancellation_point())
-    {
-#ifdef CONFIG_CANCELLATION_POINTS
-      /* If there is a pending cancellation, then do not perform
-       * the wait.  Exit now with ECANCELED.
-       */
-
-      set_errno(ECANCELED);
-      leave_cancellation_point();
-      leave_critical_section(flags);
-      return ERROR;
-#endif
-    }
-
   /* Make sure we were supplied with a valid semaphore. */
 
   if (sem != NULL)
@@ -132,6 +122,8 @@ int sem_wait(FAR sem_t *sem)
 
       else
         {
+          int saved_errno;
+
           /* First, verify that the task is not already waiting on a
            * semaphore
            */
@@ -163,22 +155,29 @@ int sem_wait(FAR sem_t *sem)
 
           nxsem_boostpriority(sem);
 #endif
+          /* Set the errno value to zero (preserving the original errno)
+           * value).  We reuse the per-thread errno to pass information
+           * between sem_waitirq() and this functions.
+           */
+
+          saved_errno   = rtcb->pterrno;
+          rtcb->pterrno = OK;
+
           /* Add the TCB to the prioritized semaphore wait queue */
 
-          set_errno(0);
           up_block_task(rtcb, TSTATE_WAIT_SEM);
 
           /* When we resume at this point, either (1) the semaphore has been
            * assigned to this thread of execution, or (2) the semaphore wait
            * has been interrupted by a signal or a timeout.  We can detect these
-           * latter cases be examining the errno value.
+           * latter cases be examining the per-thread errno value.
            *
            * In the event that the semaphore wait was interrupted by a signal or
            * a timeout, certain semaphore clean-up operations have already been
            * performed (see sem_waitirq.c).  Specifically:
            *
-           * - nxsem_canceled() was called to restore the priority of all threads
-           *   that hold a reference to the semaphore,
+           * - nxsem_canceled() was called to restore the priority of all
+           *   threads that hold a reference to the semaphore,
            * - The semaphore count was decremented, and
            * - tcb->waitsem was nullifed.
            *
@@ -188,28 +187,83 @@ int sem_wait(FAR sem_t *sem)
            * race conditions.
            */
 
-          if (get_errno() != EINTR && get_errno() != ETIMEDOUT)
-            {
-              /* Not awakened by a signal or a timeout...
-               *
-               * NOTE that in this case nxsem_addholder() was called by logic
-               * in sem_wait() fore this thread was restarted.
-               */
+          /* Check if an error occurred while we were sleeping.  Expected
+           * errors include EINTR meaning that we were awakened by a signal
+           * or ETIMEDOUT meaning that the timer expired for the case of
+           * sem_timedwait().
+           *
+           * If we were not awakened by a signal or a timeout, then
+           * nxsem_addholder() was called by logic in sem_wait() fore this
+           * thread was restarted.
+           */
 
-              ret = OK;
-            }
+          ret           = rtcb->pterrno != OK ? -rtcb->pterrno : OK;
+          rtcb->pterrno = saved_errno;
 
 #ifdef CONFIG_PRIORITY_INHERITANCE
           sched_unlock();
 #endif
         }
     }
-  else
-    {
-      set_errno(EINVAL);
-    }
 
-  leave_cancellation_point();
   leave_critical_section(flags);
   return ret;
 }
+
+/****************************************************************************
+ * Name: sem_wait
+ *
+ * Description:
+ *   This function attempts to lock the semaphore referenced by 'sem'.  If
+ *   the semaphore value is (<=) zero, then the calling task will not return
+ *   until it successfully acquires the lock.
+ *
+ * Parameters:
+ *   sem - Semaphore descriptor.
+ *
+ * Return Value:
+ *   This function is a standard, POSIX application interface.  It returns
+ *   zero (OK) if successful.  Otherwise, -1 (ERROR) is returned and
+ *   the errno value is set appropriately.  Possible errno values include:
+ *
+ *   - EINVAL:  Invalid attempt to get the semaphore
+ *   - EINTR:   The wait was interrupted by the receipt of a signal.
+ *
+ ****************************************************************************/
+
+int sem_wait(FAR sem_t *sem)
+{
+  int errcode;
+  int ret;
+
+  /* sem_wait() is a cancellation point */
+
+  if (enter_cancellation_point())
+    {
+#ifdef CONFIG_CANCELLATION_POINTS
+      /* If there is a pending cancellation, then do not perform
+       * the wait.  Exit now with ECANCELED.
+       */
+
+      errcode = ECANCELED;
+      goto errout_with_cancelpt;
+#endif
+    }
+
+  /* Let nxsem_wait() do the real work */
+
+  ret = nxsem_wait(sem);
+  if (ret < 0)
+    {
+      errcode = -ret;
+      goto errout_with_cancelpt;
+    }
+
+  leave_cancellation_point();
+  return OK;
+
+errout_with_cancelpt:
+  set_errno(errcode);
+  leave_cancellation_point();
+  return ERROR;
+}
diff --git a/sched/semaphore/sem_waitirq.c b/sched/semaphore/sem_waitirq.c
index ec74860c48..81684f3900 100644
--- a/sched/semaphore/sem_waitirq.c
+++ b/sched/semaphore/sem_waitirq.c
@@ -1,5 +1,5 @@
 /****************************************************************************
- * sched/semaphore/sem_waitirq.c
+ * sched/semaphore/nxsem_waitirq.c
  *
  *   Copyright (C) 2007-2010, 2014, 2016 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
@@ -59,7 +59,7 @@
  *
  *   1. A signal is received by a task that is waiting on a semaphore.
  *      According to the POSIX spec, "...the calling thread shall not return
- *      from the call to [sem_wait] until it either locks the semaphore or
+ *      from the call to [nxsem_wait] until it either locks the semaphore or
  *      the call is interrupted by a signal."
  *   2. From logic associated with sem_timedwait().  This function is called
  *      when the timeout elapses without receiving the semaphore.
diff --git a/sched/task/task_spawnparms.c b/sched/task/task_spawnparms.c
index b25e7712ea..d93e80a124 100644
--- a/sched/task/task_spawnparms.c
+++ b/sched/task/task_spawnparms.c
@@ -175,10 +175,10 @@ void spawn_semtake(FAR sem_t *sem)
 
   do
     {
-      ret = sem_wait(sem);
-      ASSERT(ret == 0 || get_errno() == EINTR);
+      ret = nxsem_wait(sem);
+      ASSERT(ret == 0 || ret == -EINTR);
     }
-  while (ret != 0);
+  while (ret == -EINTR);
 }
 
 /****************************************************************************
diff --git a/wireless/ieee802154/mac802154_device.c b/wireless/ieee802154/mac802154_device.c
index d35fff6fa1..66857f43b6 100644
--- a/wireless/ieee802154/mac802154_device.c
+++ b/wireless/ieee802154/mac802154_device.c
@@ -189,18 +189,18 @@ static const struct file_operations mac802154dev_fops =
 
 static inline int mac802154dev_takesem(sem_t *sem)
 {
-  /* Take a count from the semaphore, possibly waiting */
+  int ret;
 
-  if (sem_wait(sem) < 0)
-    {
-      /* EINTR is the only error that we expect */
+  /* Take the semaphore (perhaps waiting) */
 
-      int errcode = get_errno();
-      DEBUGASSERT(errcode == EINTR);
-      return -errcode;
-    }
+  ret = nxsem_wait(sem);
 
-  return OK;
+  /* The only case that an error should occur here is if the wait were
+   * awakened by a signal.
+   */
+
+  DEBUGASSERT(ret == OK || ret == -EINTR);
+  return ret;
 }
 
 /****************************************************************************
@@ -500,11 +500,12 @@ static ssize_t mac802154dev_read(FAR struct file *filep, FAR char *buffer,
 
       /* Wait to be signaled when a frame is added to the list */
 
-      if (sem_wait(&dev->readsem) < 0)
+      ret = nxsem_wait(&dev->readsem);
+      if (ret < 0)
         {
-          DEBUGASSERT(errno == EINTR);
+          DEBUGASSERT(ret == -EINTR);
           dev->readpending = false;
-          return -EINTR;
+          return ret;
         }
 
       /* Let the loop wrap back around, we will then pop a indication and this
@@ -707,11 +708,12 @@ static int mac802154dev_ioctl(FAR struct file *filep, int cmd,
 
               /* Wait to be signaled when an event is queued */
 
-              if (sem_wait(&dev->geteventsem) < 0)
+              ret = nxsem_wait(&dev->geteventsem);
+              if (ret < 0)
                 {
-                  DEBUGASSERT(errno == EINTR);
+                  DEBUGASSERT(ret == -EINTR);
                   dev->geteventpending = false;
-                  return -EINTR;
+                  return ret;
                 }
 
               /* Get exclusive access again, then loop back around and try and
diff --git a/wireless/ieee802154/mac802154_internal.h b/wireless/ieee802154/mac802154_internal.h
index f54d70dc6a..ade1f0e479 100644
--- a/wireless/ieee802154/mac802154_internal.h
+++ b/wireless/ieee802154/mac802154_internal.h
@@ -57,6 +57,7 @@
 
 #include <nuttx/wdog.h>
 #include <nuttx/wqueue.h>
+#include <nuttx/semaphore.h>
 
 #include "mac802154_notif.h"
 
@@ -554,22 +555,22 @@ static inline int mac802154_takesem(sem_t *sem, bool allowinterrupt)
     {
       /* Take a count from the semaphore, possibly waiting */
 
-      ret = sem_wait(sem);
+      ret = nxsem_wait(sem);
       if (ret < 0)
         {
           /* EINTR is the only error that we expect */
 
-          DEBUGASSERT(get_errno() == EINTR);
+          DEBUGASSERT(ret == -EINTR);
 
           if (allowinterrupt)
             {
-              return -EINTR;
+              return ret;
             }
         }
     }
-  while (ret != OK);
+  while (ret == -EINTR);
 
-  return OK;
+  return ret;
 }
 
 #ifdef CONFIG_MAC802154_LOCK_VERBOSE
diff --git a/wireless/ieee802154/mac802154_netdev.c b/wireless/ieee802154/mac802154_netdev.c
index 1bc85bf45b..e9412afa1d 100644
--- a/wireless/ieee802154/mac802154_netdev.c
+++ b/wireless/ieee802154/mac802154_netdev.c
@@ -465,7 +465,7 @@ static void macnet_notify(FAR struct mac802154_maccb_s *maccb,
   /* Get exclusive access to the driver structure.  We don't care about any
    * signals so if we see one, just go back to trying to get access again */
 
-  while (sem_wait(&priv->md_exclsem) < 0);
+  while (nxsem_wait(&priv->md_exclsem) < 0);
 
   /* If there is a registered notification receiver, queue the event and signal
    * the receiver. Events should be popped from the queue from the application
@@ -1088,10 +1088,10 @@ static int macnet_ioctl(FAR struct net_driver_s *dev, int cmd,
   FAR struct macnet_driver_s *priv = (FAR struct macnet_driver_s *)dev->d_private;
   int ret = -EINVAL;
 
-  ret = sem_wait(&priv->md_exclsem);
+  ret = nxsem_wait(&priv->md_exclsem);
   if (ret < 0)
     {
-      wlerr("ERROR: sem_wait failed: %d\n", ret);
+      wlerr("ERROR: nxsem_wait failed: %d\n", ret);
       return ret;
     }
 
@@ -1129,6 +1129,7 @@ static int macnet_ioctl(FAR struct net_driver_s *dev, int cmd,
                 }
                 break;
         #endif
+
               case MAC802154IOC_GET_EVENT:
                 {
                   FAR struct ieee802154_notif_s *notif;
@@ -1167,32 +1168,35 @@ static int macnet_ioctl(FAR struct net_driver_s *dev, int cmd,
 
                       /* Wait to be signaled when an event is queued */
 
-                      if (sem_wait(&priv->md_eventsem) < 0)
+                      ret = nxsem_wait(&priv->md_eventsem);
+                      if (ret < 0)
                         {
-                          DEBUGASSERT(errno == EINTR);
+                          DEBUGASSERT(ret == -EINTR);
                           priv->md_eventpending = false;
-                          return -EINTR;
+                          return ret;
                         }
 
                       /* Get exclusive access again, then loop back around and try and
                        * pop an event off the queue
                        */
 
-                      ret = sem_wait(&priv->md_exclsem);
+                      ret = nxsem_wait(&priv->md_exclsem);
                       if (ret < 0)
                         {
-                          wlerr("ERROR: sem_wait failed: %d\n", ret);
+                          wlerr("ERROR: nxsem_wait failed: %d\n", ret);
                           return ret;
                         }
                     }
                 }
                 break;
+
               case MAC802154IOC_ENABLE_EVENTS:
                 {
                   priv->md_enableevents = netmac->u.enable;
                   ret = OK;
                 }
                 break;
+
               default:
                 {
                   ret = mac802154_ioctl(priv->md_mac, cmd, macarg);
diff --git a/wireless/pktradio/pktradio_metadata.c b/wireless/pktradio/pktradio_metadata.c
index 7651ca4a92..585b6bac23 100644
--- a/wireless/pktradio/pktradio_metadata.c
+++ b/wireless/pktradio/pktradio_metadata.c
@@ -150,13 +150,23 @@ FAR struct pktradio_metadata_s *pktradio_metadata_allocate(void)
 {
   FAR struct pktradio_metadata_s *metadata;
   uint8_t pool;
+  int ret;
 
   /* Get exclusive access to the free list */
 
-  while (sem_wait(&g_metadata_sem) < 0)
+  do
     {
-      DEBUGASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&g_metadata_sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   /* Try the free list first */
 
@@ -216,12 +226,23 @@ FAR struct pktradio_metadata_s *pktradio_metadata_allocate(void)
 
 void pktradio_metadata_free(FAR struct pktradio_metadata_s *metadata)
 {
+  int ret;
+
   /* Get exclusive access to the free list */
 
-  while (sem_wait(&g_metadata_sem) < 0)
+  do
     {
-      DEBUGASSERT(errno == EINTR);
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = nxsem_wait(&g_metadata_sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
     }
+  while (ret == -EINTR);
 
   /* If this is a pre-allocated meta-data structure, then just put it back
    * in the free list.