Many changes to reduce complaints from CppCheck. Several latent bugs fixes, but probably some new typos introduced

82 files changed, 1997 insertions, 1659 deletions

diff --git a/nuttx/ChangeLog b/nuttx/ChangeLog
index ef67df096..bdb4fb733 100644
--- a/nuttx/ChangeLog
+++ b/nuttx/ChangeLog
@@ -6570,3 +6570,6 @@
 	  for the MIO283QT9A LCD.  From Toby Duckworth (2014-2-10).
 	* configs/mikroe-stm32f4/src/up_mio283qt9a.c: The Mikroe STM32F4 can
 	  now support the newer MIO283QT9A LCD. From Toby Duckworth (2014-2-10).
+	* MANY files changes based on complaints from the tool CppCheck.  Several
+	  latent bugs were fixed (and most likely some new typos were introducted)
+	  (2014-2-10).
diff --git a/nuttx/arch/arm/src/c5471/c5471_irq.c b/nuttx/arch/arm/src/c5471/c5471_irq.c
index 49930f60f..fc7f83e08 100644
--- a/nuttx/arch/arm/src/c5471/c5471_irq.c
+++ b/nuttx/arch/arm/src/c5471/c5471_irq.c
@@ -228,7 +228,7 @@ void up_enable_irq(int irq)
 
 void up_maskack_irq(int irq)
 {
-  uint32_t reg = getreg32(INT_CTRL_REG);
+  uint32_t reg;
 
   /* Mask the interrupt */
 
diff --git a/nuttx/arch/arm/src/c5471/c5471_watchdog.c b/nuttx/arch/arm/src/c5471/c5471_watchdog.c
index f9cf52244..489921292 100644
--- a/nuttx/arch/arm/src/c5471/c5471_watchdog.c
+++ b/nuttx/arch/arm/src/c5471/c5471_watchdog.c
@@ -261,7 +261,7 @@ static ssize_t wdt_read(struct file *filep, char *buffer, size_t buflen)
   dbg("buflen=%d\n", buflen);
   if (buflen >= 18)
     {
-      sprintf(buffer, "#08x %08x\n", c5471_wdt_cntl, c5471_wdt_count);
+      sprintf(buffer, "%08x %08x\n", c5471_wdt_cntl, c5471_wdt_count);
       return 18;
     }
   return 0;
diff --git a/nuttx/arch/arm/src/common/up_allocateheap.c b/nuttx/arch/arm/src/common/up_allocateheap.c
index 9435a55b2..a5c1a068c 100644
--- a/nuttx/arch/arm/src/common/up_allocateheap.c
+++ b/nuttx/arch/arm/src/common/up_allocateheap.c
@@ -112,7 +112,6 @@ void up_allocate_heap(FAR void **heap_start, size_t *heap_size)
 
   uintptr_t ubase = (uintptr_t)USERSPACE->us_bssend + CONFIG_MM_KERNEL_HEAPSIZE;
   size_t    usize = CONFIG_RAM_END - ubase;
-  int       log2;
 
   DEBUGASSERT(ubase < (uintptr_t)CONFIG_RAM_END);
 
@@ -151,9 +150,6 @@ void up_allocate_kheap(FAR void **heap_start, size_t *heap_size)
    */
 
   uintptr_t ubase = (uintptr_t)USERSPACE->us_bssend + CONFIG_MM_KERNEL_HEAPSIZE;
-  size_t    usize = CONFIG_RAM_END - ubase;
-  int       log2;
-
   DEBUGASSERT(ubase < (uintptr_t)CONFIG_RAM_END);
 
   /* Return the kernel heap settings (i.e., the part of the heap region
diff --git a/nuttx/arch/arm/src/dm320/dm320_framebuffer.c b/nuttx/arch/arm/src/dm320/dm320_framebuffer.c
index 0b118e4df..1abc02802 100644
--- a/nuttx/arch/arm/src/dm320/dm320_framebuffer.c
+++ b/nuttx/arch/arm/src/dm320/dm320_framebuffer.c
@@ -1254,7 +1254,7 @@ static int dm320_getcursor(FAR struct fb_vtable_s *vtable, FAR struct fb_cursora
   attrib->size.w = getreg16(DM320_OSD_CURXL);
   attrib->size.h = getreg16(DM320_OSD_CURYL);
 #endif
-  irqrestore();
+  irqrestore(flags);
 
   attrib->mxsize.w = MAX_XRES;
   attrib->mxsize.h = MAX_YRES;
@@ -1325,10 +1325,8 @@ static int dm320_setcursor(FAR struct fb_vtable_s *vtable, FAR struct fb_setcurs
           settings->size.h = MAX_YRES;
        }
 
-     flags = irqsave();
      putreg16(settings->size.w, DM320_OSD_CURXL);
      putreg16(settings->size.h, DM320_OSD_CURYL);
-     restore_flags(flags);
    }
 #endif
 
@@ -1342,7 +1340,7 @@ static int dm320_setcursor(FAR struct fb_vtable_s *vtable, FAR struct fb_setcurs
       regval &= ~1;
     }
   putreg16(regval, DM320_OSD_RECTCUR);
-  restore_flags(flags);
+  irqrestore(flags);
 
   gvdbg("DM320_OSD_CURXP:       %04x\n", getreg16(DM320_OSD_CURXP));
   gvdbg("DM320_OSD_CURYP:       %04x\n", getreg16(DM320_OSD_CURYP));
diff --git a/nuttx/arch/arm/src/dm320/dm320_usbdev.c b/nuttx/arch/arm/src/dm320/dm320_usbdev.c
index b30aba72c..97804b492 100644
--- a/nuttx/arch/arm/src/dm320/dm320_usbdev.c
+++ b/nuttx/arch/arm/src/dm320/dm320_usbdev.c
@@ -1761,7 +1761,7 @@ static inline void dm320_epinitialize(struct dm320_usbdev_s *priv)
 
           /* FIFO address, max packet size, dual/single buffered */
 
-          dm320_putreg8(addrhi, DM320_USB_TXFIFO1);
+          dm320_putreg8(addrlo, DM320_USB_TXFIFO1);
           dm320_putreg8(addrhi|g_epinfo[i].fifo, DM320_USB_TXFIFO2);
 
           /* TX endpoint max packet size */
diff --git a/nuttx/arch/arm/src/imx/imx_serial.c b/nuttx/arch/arm/src/imx/imx_serial.c
index d7ac1a732..08f57eeda 100644
--- a/nuttx/arch/arm/src/imx/imx_serial.c
+++ b/nuttx/arch/arm/src/imx/imx_serial.c
@@ -879,8 +879,10 @@ static int up_interrupt(int irq, void *context)
 
 static int up_ioctl(struct file *filep, int cmd, unsigned long arg)
 {
+#ifdef CONFIG_SERIAL_TIOCSERGSTRUCT
   struct inode      *inode = filep->f_inode;
   struct uart_dev_s *dev   = inode->i_private;
+#endif
   int                ret   = OK;
 
   switch (cmd)
diff --git a/nuttx/arch/arm/src/imx/imx_spi.c b/nuttx/arch/arm/src/imx/imx_spi.c
index 0243b67df..83a3897a1 100644
--- a/nuttx/arch/arm/src/imx/imx_spi.c
+++ b/nuttx/arch/arm/src/imx/imx_spi.c
@@ -500,10 +500,10 @@ static int spi_transfer(struct imx_spidev_s *priv, const void *txbuffer,
 {
 #ifndef CONFIG_SPI_POLLWAIT
   irqstate_t flags;
-#endif
   uint32_t regval;
-  int ntxd;
   int ret;
+#endif
+  int ntxd;
 
   /* Set up to perform the transfer */
 
diff --git a/nuttx/arch/arm/src/kl/kl_serial.c b/nuttx/arch/arm/src/kl/kl_serial.c
index faf9a7106..2622e0db0 100644
--- a/nuttx/arch/arm/src/kl/kl_serial.c
+++ b/nuttx/arch/arm/src/kl/kl_serial.c
@@ -709,7 +709,7 @@ static void up_rxint(struct uart_dev_s *dev, bool enable)
     }
   else
     {
-      priv->ie |= UART_C2_RIE;
+      priv->ie &= ~UART_C2_RIE;
       up_setuartint(priv);
     }
 
diff --git a/nuttx/arch/arm/src/lm/lm_start.c b/nuttx/arch/arm/src/lm/lm_start.c
index 96cb79822..184170dbf 100644
--- a/nuttx/arch/arm/src/lm/lm_start.c
+++ b/nuttx/arch/arm/src/lm/lm_start.c
@@ -100,7 +100,9 @@ extern void _vectors(void);
 
 void __start(void)
 {
+#ifdef CONFIG_BOOT_RUNFROMFLASH
   const uint32_t *src;
+#endif
   uint32_t *dest;
 
   /* Configure the uart so that we can get debug output as soon as possible */
diff --git a/nuttx/arch/arm/src/lpc31xx/lpc31_i2c.c b/nuttx/arch/arm/src/lpc31xx/lpc31_i2c.c
index 3d65c302d..73b9ab720 100644
--- a/nuttx/arch/arm/src/lpc31xx/lpc31_i2c.c
+++ b/nuttx/arch/arm/src/lpc31xx/lpc31_i2c.c
@@ -72,49 +72,50 @@
  * Pre-processor Definitions
  ****************************************************************************/
 
-#define I2C_TIMEOUT		((20 * CLK_TCK) / 1000)	/* 20 mS */
+#define I2C_TIMEOUT  ((20 * CLK_TCK) / 1000)      /* 20 mS */
 
 /****************************************************************************
  * Private Data
  ****************************************************************************/
 struct lpc31_i2cdev_s
 {
-    struct i2c_dev_s            dev;		/* Generic I2C device */
-    struct i2c_msg_s            msg;		/* a single message for legacy read/write */
-    unsigned int 		base;		/* Base address of registers */
-    uint16_t            	clkid;		/* Clock for this device */
-    uint16_t            	rstid;		/* Reset for this device */
-    uint16_t                    irqid;		/* IRQ for this device */
-
-    sem_t	 		mutex;		/* Only one thread can access at a time */
-
-    sem_t        		wait;		/* Place to wait for state machine completion */
-    volatile uint8_t		state;		/* State of state machine */
-    WDOG_ID			timeout;	/* watchdog to timeout when bus hung */
-
-    struct i2c_msg_s		*msgs;		/* remaining transfers - first one is in progress */
-    unsigned int                 nmsg;		/* number of transfer remaining */
-
-    uint16_t                     header[3];	/* I2C address header */
-    uint16_t                     hdrcnt; 	/* number of bytes of header */
-    uint16_t                     wrcnt;		/* number of bytes sent to tx fifo */
-    uint16_t                     rdcnt;		/* number of bytes read from rx fifo */
+    struct i2c_dev_s  dev;        /* Generic I2C device */
+    struct i2c_msg_s  msg;        /* a single message for legacy read/write */
+    unsigned int      base;       /* Base address of registers */
+    uint16_t          clkid;      /* Clock for this device */
+    uint16_t          rstid;      /* Reset for this device */
+    uint16_t          irqid;      /* IRQ for this device */
+
+    sem_t             mutex;      /* Only one thread can access at a time */
+
+    sem_t             wait;       /* Place to wait for state machine completion */
+    volatile uint8_t  state;      /* State of state machine */
+    WDOG_ID           timeout;    /* watchdog to timeout when bus hung */
+
+    struct i2c_msg_s *msgs;       /* remaining transfers - first one is in progress */
+    unsigned int      nmsg;       /* number of transfer remaining */
+
+    uint16_t          header[3];  /* I2C address header */
+    uint16_t          hdrcnt;     /* number of bytes of header */
+    uint16_t          wrcnt;      /* number of bytes sent to tx fifo */
+    uint16_t          rdcnt;      /* number of bytes read from rx fifo */
 };
 
-#define I2C_STATE_DONE		0
-#define I2C_STATE_START		1
-#define I2C_STATE_HEADER	2
-#define I2C_STATE_TRANSFER	3
+#define I2C_STATE_DONE      0
+#define I2C_STATE_START     1
+#define I2C_STATE_HEADER    2
+#define I2C_STATE_TRANSFER  3
 
 static struct lpc31_i2cdev_s i2cdevices[2];
 
 /****************************************************************************
  * Private Functions
  ****************************************************************************/
-static int  i2c_interrupt (int irq, FAR void *context);
-static void i2c_progress (struct lpc31_i2cdev_s *priv);
-static void i2c_timeout (int argc, uint32_t arg, ...);
-static void i2c_reset (struct lpc31_i2cdev_s *priv);
+
+static int  i2c_interrupt(int irq, FAR void *context);
+static void i2c_progress(struct lpc31_i2cdev_s *priv);
+static void i2c_timeout(int argc, uint32_t arg, ...);
+static void i2c_reset(struct lpc31_i2cdev_s *priv);
 
 /****************************************************************************
  * Public Functions
@@ -130,13 +131,14 @@ static int      i2c_write(FAR struct i2c_dev_s *dev, const uint8_t *buffer, int
 static int      i2c_read(FAR struct i2c_dev_s *dev, uint8_t *buffer, int buflen);
 static int      i2c_transfer(FAR struct i2c_dev_s *dev, FAR struct i2c_msg_s *msgs, int count);
 
-struct i2c_ops_s lpc31_i2c_ops = {
-    .setfrequency = i2c_setfrequency,
-    .setaddress   = i2c_setaddress,
-    .write        = i2c_write,
-    .read         = i2c_read,
+struct i2c_ops_s lpc31_i2c_ops =
+{
+  .setfrequency = i2c_setfrequency,
+  .setaddress   = i2c_setaddress,
+  .write        = i2c_write,
+  .read         = i2c_read,
 #ifdef CONFIG_I2C_TRANSFER
-    .transfer     = i2c_transfer
+  .transfer     = i2c_transfer
 #endif
 };
 
@@ -151,41 +153,41 @@ struct i2c_ops_s lpc31_i2c_ops = {
 struct i2c_dev_s *up_i2cinitialize(int port)
 {
   struct lpc31_i2cdev_s *priv = &i2cdevices[port];
-    
+
   priv->base  = (port == 0) ? LPC31_I2C0_VBASE : LPC31_I2C1_VBASE;
   priv->clkid = (port == 0) ? CLKID_I2C0PCLK     : CLKID_I2C1PCLK;
   priv->rstid = (port == 0) ? RESETID_I2C0RST    : RESETID_I2C1RST;
   priv->irqid = (port == 0) ? LPC31_IRQ_I2C0   : LPC31_IRQ_I2C1;
-  
-  sem_init (&priv->mutex, 0, 1);
-  sem_init (&priv->wait, 0, 0);
-  
+
+  sem_init(&priv->mutex, 0, 1);
+  sem_init(&priv->wait, 0, 0);
+
   /* Enable I2C system clocks */
-  
-  lpc31_enableclock (priv->clkid);
-  
+
+  lpc31_enableclock(priv->clkid);
+
   /* Reset I2C blocks */
-  
-  lpc31_softreset (priv->rstid);
-  
+
+  lpc31_softreset(priv->rstid);
+
   /* Soft reset the device */
-  
-  i2c_reset (priv);
-  
+
+  i2c_reset(priv);
+
   /* Allocate a watchdog timer */
   priv->timeout = wd_create();
 
   DEBUGASSERT(priv->timeout != 0);
-  
+
   /* Attach Interrupt Handler */
-  irq_attach (priv->irqid, i2c_interrupt);
-  
+  irq_attach(priv->irqid, i2c_interrupt);
+
   /* Enable Interrupt Handler */
   up_enable_irq(priv->irqid);
 
   /* Install our operations */
   priv->dev.ops = &lpc31_i2c_ops;
-  
+
   return &priv->dev;
 }
 
@@ -197,23 +199,23 @@ struct i2c_dev_s *up_i2cinitialize(int port)
  *
  *******************************************************************************/
 
-void up_i2cuninitalize (struct lpc31_i2cdev_s *priv)
+void up_i2cuninitalize(struct lpc31_i2cdev_s *priv)
 {
   /* Disable All Interrupts, soft reset the device */
 
-  i2c_reset (priv);
-  
+  i2c_reset(priv);
+
   /* Detach Interrupt Handler */
-  
-  irq_detach (priv->irqid);
-  
+
+  irq_detach(priv->irqid);
+
   /* Reset I2C blocks */
-  
-  lpc31_softreset (priv->rstid);
-  
+
+  lpc31_softreset(priv->rstid);
+
   /* Disable I2C system clocks */
-  
-  lpc31_disableclock (priv->clkid);
+
+  lpc31_disableclock(priv->clkid);
 }
 
 /*******************************************************************************
@@ -228,22 +230,25 @@ static uint32_t i2c_setfrequency(FAR struct i2c_dev_s *dev, uint32_t frequency)
 {
   struct lpc31_i2cdev_s *priv = (struct lpc31_i2cdev_s *) dev;
 
-  uint32_t freq = lpc31_clkfreq (priv->clkid, DOMAINID_AHB0APB1);
+  uint32_t freq = lpc31_clkfreq(priv->clkid, DOMAINID_AHB0APB1);
 
   if (freq > 100000)
-  {
+    {
       /* asymetric per 400Khz I2C spec */
-      putreg32 (((47 * freq) / (83 + 47)) / frequency, priv->base + LPC31_I2C_CLKHI_OFFSET);
-      putreg32 (((83 * freq) / (83 + 47)) / frequency, priv->base + LPC31_I2C_CLKLO_OFFSET);
-  }
+
+      putreg32(((47 * freq) / (83 + 47)) / frequency, priv->base + LPC31_I2C_CLKHI_OFFSET);
+      putreg32(((83 * freq) / (83 + 47)) / frequency, priv->base + LPC31_I2C_CLKLO_OFFSET);
+    }
   else
-  {
+    {
       /* 50/50 mark space ratio */
-      putreg32 (((50 * freq) / 100) / frequency, priv->base + LPC31_I2C_CLKLO_OFFSET);
-      putreg32 (((50 * freq) / 100) / frequency, priv->base + LPC31_I2C_CLKHI_OFFSET);
-  }
+
+      putreg32(((50 * freq) / 100) / frequency, priv->base + LPC31_I2C_CLKLO_OFFSET);
+      putreg32(((50 * freq) / 100) / frequency, priv->base + LPC31_I2C_CLKHI_OFFSET);
+    }
 
   /* FIXME: This function should return the actual selected frequency */
+
   return frequency;
 }
 
@@ -254,6 +259,7 @@ static uint32_t i2c_setfrequency(FAR struct i2c_dev_s *dev, uint32_t frequency)
  *   Set the I2C slave address for a subsequent read/write
  *
  *******************************************************************************/
+
 static int i2c_setaddress(FAR struct i2c_dev_s *dev, int addr, int nbits)
 {
   struct lpc31_i2cdev_s *priv = (struct lpc31_i2cdev_s *) dev;
@@ -275,20 +281,21 @@ static int i2c_setaddress(FAR struct i2c_dev_s *dev, int addr, int nbits)
  *   frequency and slave address.
  *
  *******************************************************************************/
+
 static int i2c_write(FAR struct i2c_dev_s *dev, const uint8_t *buffer, int buflen)
 {
-    struct lpc31_i2cdev_s *priv = (struct lpc31_i2cdev_s *) dev;
-    int ret;
+  struct lpc31_i2cdev_s *priv = (struct lpc31_i2cdev_s *) dev;
+  int ret;
+
+  DEBUGASSERT(dev != NULL);
 
-    DEBUGASSERT (dev != NULL);
-    
-    priv->msg.flags &= ~I2C_M_READ;
-    priv->msg.buffer = (uint8_t*)buffer;
-    priv->msg.length = buflen;
+  priv->msg.flags &= ~I2C_M_READ;
+  priv->msg.buffer = (uint8_t*)buffer;
+  priv->msg.length = buflen;
 
-    ret = i2c_transfer (dev, &priv->msg, 1);
+  ret = i2c_transfer(dev, &priv->msg, 1);
 
-    return ret == 1 ? OK : -ETIMEDOUT;
+  return ret == 1 ? OK : -ETIMEDOUT;
 }
 
 /*******************************************************************************
@@ -299,20 +306,21 @@ static int i2c_write(FAR struct i2c_dev_s *dev, const uint8_t *buffer, int bufle
  *   frequency and slave address.
  *
  *******************************************************************************/
+
 static int i2c_read(FAR struct i2c_dev_s *dev, uint8_t *buffer, int buflen)
 {
-    struct lpc31_i2cdev_s *priv = (struct lpc31_i2cdev_s *) dev;
-    int ret;
+  struct lpc31_i2cdev_s *priv = (struct lpc31_i2cdev_s *) dev;
+  int ret;
+
+  DEBUGASSERT(dev != NULL);
 
-    DEBUGASSERT (dev != NULL);
-    
-    priv->msg.flags |= I2C_M_READ;
-    priv->msg.buffer = buffer;
-    priv->msg.length = buflen;
+  priv->msg.flags |= I2C_M_READ;
+  priv->msg.buffer = buffer;
+  priv->msg.length = buflen;
 
-    ret = i2c_transfer (dev, &priv->msg, 1);
+  ret = i2c_transfer(dev, &priv->msg, 1);
 
-    return ret == 1 ? OK : -ETIMEDOUT;
+  return ret == 1 ? OK : -ETIMEDOUT;
 }
 
 /*******************************************************************************
@@ -323,37 +331,39 @@ static int i2c_read(FAR struct i2c_dev_s *dev, uint8_t *buffer, int buflen)
  *
  *******************************************************************************/
 
-static int i2c_transfer (FAR struct i2c_dev_s *dev, FAR struct i2c_msg_s *msgs, int count)
+static int i2c_transfer(FAR struct i2c_dev_s *dev, FAR struct i2c_msg_s *msgs, int count)
 {
   struct lpc31_i2cdev_s *priv = (struct lpc31_i2cdev_s *) dev;
   irqstate_t flags;
   int ret;
-  
-  sem_wait (&priv->mutex);
+
+  sem_wait(&priv->mutex);
   flags = irqsave();
-  
+
   priv->state = I2C_STATE_START;
   priv->msgs  = msgs;
   priv->nmsg  = count;
-  
-  i2c_progress (priv);
+
+  i2c_progress(priv);
 
   /* start a watchdog to timeout the transfer if
-   * the bus is locked up... */
-  wd_start (priv->timeout, I2C_TIMEOUT, i2c_timeout, 1, (uint32_t)priv);
-  
+   * the bus is locked up...
+   */
+
+  wd_start(priv->timeout, I2C_TIMEOUT, i2c_timeout, 1, (uint32_t)priv);
+
   while (priv->state != I2C_STATE_DONE)
     {
-      sem_wait (&priv->wait);
+      sem_wait(&priv->wait);
     }
 
-  wd_cancel (priv->timeout);
-  
+  wd_cancel(priv->timeout);
+
   ret = count - priv->nmsg;
-  
-  irqrestore (flags);
-  sem_post (&priv->mutex);
-  
+
+  irqrestore(flags);
+  sem_post(&priv->mutex);
+
   return ret;
 }
 
@@ -365,16 +375,16 @@ static int i2c_transfer (FAR struct i2c_dev_s *dev, FAR struct i2c_msg_s *msgs,
  *
  *******************************************************************************/
 
-static int i2c_interrupt (int irq, FAR void *context)
+static int i2c_interrupt(int irq, FAR void *context)
 {
   if (irq == LPC31_IRQ_I2C0)
     {
-      i2c_progress (&i2cdevices[0]);
+      i2c_progress(&i2cdevices[0]);
     }
 
   if (irq == LPC31_IRQ_I2C1)
     {
-      i2c_progress (&i2cdevices[1]);
+      i2c_progress(&i2cdevices[1]);
     }
 
   return OK;
@@ -388,170 +398,194 @@ static int i2c_interrupt (int irq, FAR void *context)
  *
  *******************************************************************************/
 
-static void i2c_progress (struct lpc31_i2cdev_s *priv)
+static void i2c_progress(struct lpc31_i2cdev_s *priv)
 {
   struct i2c_msg_s *msg;
   uint32_t stat, ctrl;
 
-  stat = getreg32 (priv->base + LPC31_I2C_STAT_OFFSET);
+  stat = getreg32(priv->base + LPC31_I2C_STAT_OFFSET);
 
   /* Were there arbitration problems? */
+
   if ((stat & I2C_STAT_AFI) != 0)
     {
       /* Perform a soft reset */
-      i2c_reset (priv);
-      
+
+      i2c_reset(priv);
+
       /* FIXME: automatic retry? */
-      
+
       priv->state = I2C_STATE_DONE;
-      sem_post (&priv->wait);
+      sem_post(&priv->wait);
       return;
     }
-  
+
   while (priv->nmsg > 0)
     {
       ctrl = I2C_CTRL_NAIE | I2C_CTRL_AFIE | I2C_CTRL_TDIE;
       msg  = priv->msgs;
-      
+
       switch (priv->state)
         {
-	case I2C_STATE_START:
-	  if ((msg->flags & I2C_M_TEN) != 0)
-	    {
-	      priv->header[0] = I2C_TX_START | 0xF0 | ((msg->addr & 0x300) >> 7);
-	      priv->header[1] = msg->addr & 0xFF;
-	      priv->hdrcnt = 2;
-	      if (msg->flags & I2C_M_READ)
-	        {
-		  priv->header[2] = priv->header[0] | 1;
-		  priv->hdrcnt++;
-		}
-	    }
-	  else
-	    {
-	      priv->header[0] = I2C_TX_START | (msg->addr << 1) | (msg->flags & I2C_M_READ);
-	      priv->hdrcnt = 1;
-	    }
-
-	  putreg32 (ctrl, priv->base + LPC31_I2C_CTRL_OFFSET);
-
-	  priv->state = I2C_STATE_HEADER;
-	  priv->wrcnt = 0;
-	  /* DROP THROUGH */
-	  
-	case I2C_STATE_HEADER:
-	  while ((priv->wrcnt != priv->hdrcnt) && (stat & I2C_STAT_TFF) == 0)
-	    {
-	      putreg32(priv->header[priv->wrcnt], priv->base + LPC31_I2C_TX_OFFSET);
-	      priv->wrcnt++;
-	      
-	      stat = getreg32 (priv->base + LPC31_I2C_STAT_OFFSET);
-	    }
-	  
-	  if (priv->wrcnt < priv->hdrcnt)
-	    {
-	      /* Enable Tx FIFO Not Full Interrupt */
-	      putreg32 (ctrl | I2C_CTRL_TFFIE, priv->base + LPC31_I2C_CTRL_OFFSET);
-	      goto out;
-	    }
-	  
-	  priv->state = I2C_STATE_TRANSFER;
-	  priv->wrcnt = 0;
-	  priv->rdcnt = 0;
-	  /* DROP THROUGH */
-	  
-	case I2C_STATE_TRANSFER:
-	  if (msg->flags & I2C_M_READ)
-	    {
-	      while ((priv->rdcnt != msg->length) && (stat & I2C_STAT_RFE) == 0)
-	        {
-		  msg->buffer[priv->rdcnt] = getreg32 (priv->base + LPC31_I2C_RX_OFFSET);
-		  priv->rdcnt++;
-		  
-		  stat = getreg32 (priv->base + LPC31_I2C_STAT_OFFSET);
-		}
-	      
-	      if (priv->rdcnt < msg->length)
-	        {
-		  /* Not all data received, fill the Tx FIFO with more dummies */
-		  while ((priv->wrcnt != msg->length) && (stat & I2C_STAT_TFF) == 0)
-		    {
-		      if ((priv->wrcnt + 1) == msg->length && priv->nmsg == 1)
-			  putreg32 (I2C_TX_STOP, priv->base + LPC31_I2C_TX_OFFSET);
-		      else
-			  putreg32 (0, priv->base + LPC31_I2C_TX_OFFSET);
-		      priv->wrcnt++;
-		      
-		      stat = getreg32 (priv->base + LPC31_I2C_STAT_OFFSET);
-		    }
-		  
-		  if (priv->wrcnt < msg->length)
-		    {
-		      /* Enable Tx FIFO not full and Rx Fifo Avail Interrupts */
-		      putreg32 (ctrl | I2C_CTRL_TFFIE | I2C_CTRL_RFDAIE, priv->base + LPC31_I2C_CTRL_OFFSET);
-		    }
-		  else
-		    {
-		      /* Enable Rx Fifo Avail Interrupts */
-		      putreg32 (ctrl | I2C_CTRL_RFDAIE, priv->base + LPC31_I2C_CTRL_OFFSET);
-		    }
-		  goto out;
-		}
-	    }
-	  else	/* WRITE */
-	    {
-	      while ((priv->wrcnt != msg->length) && (stat & I2C_STAT_TFF) == 0)
-	        {
-		  if ((priv->wrcnt + 1) == msg->length && priv->nmsg == 1)
-		      putreg32 (I2C_TX_STOP | msg->buffer[priv->wrcnt], priv->base + LPC31_I2C_TX_OFFSET);
-		  else
-		      putreg32 (msg->buffer[priv->wrcnt], priv->base + LPC31_I2C_TX_OFFSET);
-		  
-		  priv->wrcnt++;
-		  
-		  stat = getreg32 (priv->base + LPC31_I2C_STAT_OFFSET);
-		}
-	      
-	      if (priv->wrcnt < msg->length)
-	        {
-		  /* Enable Tx Fifo not full Interrupt */
-		  putreg32 (ctrl | I2C_CTRL_TFFIE, priv->base + LPC31_I2C_CTRL_OFFSET);
-		  goto out;
-		}
-	    }
-	  
-	  /* Transfer completed, move onto the next one */
-	  priv->state = I2C_STATE_START;
-	  
-	  if (--priv->nmsg == 0)
-	    {
-	      /* Final transfer, wait for Transmit Done Interrupt */
-	      putreg32 (ctrl, priv->base + LPC31_I2C_CTRL_OFFSET);
-	      goto out;
-	    }
-	  priv->msgs++;
-	  break;
-      }
-  }
-
-out:      
+        case I2C_STATE_START:
+          if ((msg->flags & I2C_M_TEN) != 0)
+            {
+              priv->header[0] = I2C_TX_START | 0xF0 | ((msg->addr & 0x300) >> 7);
+              priv->header[1] = msg->addr & 0xFF;
+              priv->hdrcnt = 2;
+              if (msg->flags & I2C_M_READ)
+                {
+                  priv->header[2] = priv->header[0] | 1;
+                  priv->hdrcnt++;
+                }
+            }
+          else
+            {
+              priv->header[0] = I2C_TX_START | (msg->addr << 1) | (msg->flags & I2C_M_READ);
+              priv->hdrcnt = 1;
+            }
+
+          putreg32(ctrl, priv->base + LPC31_I2C_CTRL_OFFSET);
+
+          priv->state = I2C_STATE_HEADER;
+          priv->wrcnt = 0;
+          /* DROP THROUGH */
+
+        case I2C_STATE_HEADER:
+          while ((priv->wrcnt != priv->hdrcnt) && (stat & I2C_STAT_TFF) == 0)
+            {
+              putreg32(priv->header[priv->wrcnt], priv->base + LPC31_I2C_TX_OFFSET);
+              priv->wrcnt++;
+
+              stat = getreg32(priv->base + LPC31_I2C_STAT_OFFSET);
+            }
+
+          if (priv->wrcnt < priv->hdrcnt)
+            {
+              /* Enable Tx FIFO Not Full Interrupt */
+
+              putreg32(ctrl | I2C_CTRL_TFFIE, priv->base + LPC31_I2C_CTRL_OFFSET);
+              goto out;
+            }
+
+          priv->state = I2C_STATE_TRANSFER;
+          priv->wrcnt = 0;
+          priv->rdcnt = 0;
+          /* DROP THROUGH */
+
+        case I2C_STATE_TRANSFER:
+          if (msg->flags & I2C_M_READ)
+            {
+              while ((priv->rdcnt != msg->length) && (stat & I2C_STAT_RFE) == 0)
+                {
+                  msg->buffer[priv->rdcnt] = getreg32 (priv->base + LPC31_I2C_RX_OFFSET);
+                  priv->rdcnt++;
+
+                  stat = getreg32(priv->base + LPC31_I2C_STAT_OFFSET);
+                }
+
+              if (priv->rdcnt < msg->length)
+                {
+                  /* Not all data received, fill the Tx FIFO with more dummies */
+
+                  while ((priv->wrcnt != msg->length) && (stat & I2C_STAT_TFF) == 0)
+                    {
+                      if ((priv->wrcnt + 1) == msg->length && priv->nmsg == 1)
+                        {
+                          putreg32(I2C_TX_STOP, priv->base + LPC31_I2C_TX_OFFSET);
+                        }
+                      else
+                        {
+                          putreg32(0, priv->base + LPC31_I2C_TX_OFFSET);
+                        }
+
+                      priv->wrcnt++;
+
+                      stat = getreg32(priv->base + LPC31_I2C_STAT_OFFSET);
+                    }
+
+                  if (priv->wrcnt < msg->length)
+                    {
+                      /* Enable Tx FIFO not full and Rx Fifo Avail Interrupts */
+
+                      putreg32(ctrl | I2C_CTRL_TFFIE | I2C_CTRL_RFDAIE, priv->base + LPC31_I2C_CTRL_OFFSET);
+                    }
+                  else
+                    {
+                      /* Enable Rx Fifo Avail Interrupts */
+
+                      putreg32(ctrl | I2C_CTRL_RFDAIE, priv->base + LPC31_I2C_CTRL_OFFSET);
+                    }
+                  goto out;
+                }
+            }
+          else    /* WRITE */
+            {
+              while ((priv->wrcnt != msg->length) && (stat & I2C_STAT_TFF) == 0)
+                {
+                  if ((priv->wrcnt + 1) == msg->length && priv->nmsg == 1)
+                    {
+                      putreg32(I2C_TX_STOP | msg->buffer[priv->wrcnt], priv->base + LPC31_I2C_TX_OFFSET);
+                    }
+                  else
+                    {
+                      putreg32(msg->buffer[priv->wrcnt], priv->base + LPC31_I2C_TX_OFFSET);
+                    }
+
+                  priv->wrcnt++;
+
+                  stat = getreg32(priv->base + LPC31_I2C_STAT_OFFSET);
+                }
+
+              if (priv->wrcnt < msg->length)
+                {
+                  /* Enable Tx Fifo not full Interrupt */
+
+                  putreg32(ctrl | I2C_CTRL_TFFIE, priv->base + LPC31_I2C_CTRL_OFFSET);
+                  goto out;
+                }
+            }
+
+          /* Transfer completed, move onto the next one */
+
+          priv->state = I2C_STATE_START;
+
+          if (--priv->nmsg == 0)
+            {
+              /* Final transfer, wait for Transmit Done Interrupt */
+
+              putreg32(ctrl, priv->base + LPC31_I2C_CTRL_OFFSET);
+              goto out;
+            }
+
+          priv->msgs++;
+          break;
+        }
+    }
+
+out:
   if (stat & I2C_STAT_TDI)
     {
-      putreg32 (I2C_STAT_TDI, priv->base + LPC31_I2C_STAT_OFFSET);
+      putreg32(I2C_STAT_TDI, priv->base + LPC31_I2C_STAT_OFFSET);
 
       /* You'd expect the NAI bit to be set when no acknowledge was
-       * received - but it gets cleared whenever a write it done to 
+       * received - but it gets cleared whenever a write it done to
        * the TXFIFO - so we've gone and cleared it while priming the
-       * rest of the transfer! */
-      if ((stat = getreg32 (priv->base + LPC31_I2C_TXFL_OFFSET)) != 0)
-      {
-	  if (priv->nmsg == 0)
-	      priv->nmsg++;
-	  i2c_reset (priv);
-      }
-      
+       * rest of the transfer!
+       */
+
+      if ((stat = getreg32(priv->base + LPC31_I2C_TXFL_OFFSET)) != 0)
+        {
+          if (priv->nmsg == 0)
+            {
+              priv->nmsg++;
+            }
+
+          i2c_reset(priv);
+        }
+
       priv->state = I2C_STATE_DONE;
-      sem_post (&priv->wait);
+      sem_post(&priv->wait);
     }
 }
 
@@ -563,32 +597,37 @@ out:
  *
  *******************************************************************************/
 
-static void i2c_timeout (int argc, uint32_t arg, ...)
+static void i2c_timeout(int argc, uint32_t arg, ...)
 {
-    struct lpc31_i2cdev_s *priv = (struct lpc31_i2cdev_s *) arg;
+  struct lpc31_i2cdev_s *priv = (struct lpc31_i2cdev_s *) arg;
+
+  irqstate_t flags = irqsave();
 
-    irqstate_t flags = irqsave();
-    
-    if (priv->state != I2C_STATE_DONE)
+  if (priv->state != I2C_STATE_DONE)
     {
-	/* If there's data remaining in the TXFIFO, then ensure at least 
-	 * one transfer has failed to complete.. */
+      /* If there's data remaining in the TXFIFO, then ensure at least
+       * one transfer has failed to complete.
+       */
+
+      if (getreg32(priv->base + LPC31_I2C_TXFL_OFFSET) != 0)
+        {
+          if (priv->nmsg == 0)
+            {
+              priv->nmsg++;
+            }
+        }
 
-	if (getreg32 (priv->base + LPC31_I2C_TXFL_OFFSET) != 0)
-	{
-	    if (priv->nmsg == 0)
-		priv->nmsg++;
-	}
+      /* Soft reset the USB controller */
 
-	/* Soft reset the USB controller */
-	i2c_reset (priv);
+      i2c_reset(priv);
 
-	/* Mark the transfer as finished */
-	priv->state = I2C_STATE_DONE;
-	sem_post (&priv->wait);
+      /* Mark the transfer as finished */
+
+      priv->state = I2C_STATE_DONE;
+      sem_post(&priv->wait);
     }
-    
-    irqrestore (flags);
+
+  irqrestore(flags);
 }
 
 /*******************************************************************************
@@ -598,11 +637,12 @@ static void i2c_timeout (int argc, uint32_t arg, ...)
  *   Perform a soft reset of the I2C controller
  *
  *******************************************************************************/
-static void i2c_reset (struct lpc31_i2cdev_s *priv)
+static void i2c_reset(struct lpc31_i2cdev_s *priv)
 {
-  putreg32 (I2C_CTRL_RESET, priv->base + LPC31_I2C_CTRL_OFFSET);
+  putreg32(I2C_CTRL_RESET, priv->base + LPC31_I2C_CTRL_OFFSET);
 
   /* Wait for Reset to complete */
-  while ((getreg32 (priv->base + LPC31_I2C_CTRL_OFFSET) & I2C_CTRL_RESET) != 0)
+
+  while ((getreg32(priv->base + LPC31_I2C_CTRL_OFFSET) & I2C_CTRL_RESET) != 0)
       ;
 }
diff --git a/nuttx/arch/arm/src/sam34/sam4l_gpio.c b/nuttx/arch/arm/src/sam34/sam4l_gpio.c
index 977e91e60..bb312db0b 100644
--- a/nuttx/arch/arm/src/sam34/sam4l_gpio.c
+++ b/nuttx/arch/arm/src/sam34/sam4l_gpio.c
@@ -214,7 +214,7 @@ static inline int sam_configinterrupt(uintptr_t base, uint32_t pin,
        *   11 Reserved
        */
 
-      gpio_pinset_t edges = cfgset & GPIO_INT_MASK;
+      gpio_pinset_t edges = (cfgset & GPIO_INT_MASK);
 
       if (edges == GPIO_INT_RISING)
         {
@@ -398,16 +398,16 @@ static inline int sam_configperiph(uintptr_t base, uint32_t pin,
    *   11 Reserved
    */
 
-  edges = cfgset & GPIO_INT_MASK;
+  edges = (cfgset & GPIO_INT_MASK);
   if (edges == GPIO_INT_RISING)
     {
-      /* Rising only.. disable interrrupts on the falling edge */
+      /* Rising only.. disable interrupts on the falling edge */
 
       putreg32(pin, base + SAM_GPIO_IMR0S_OFFSET);
     }
   else if (edges == GPIO_INT_FALLING)
     {
-      /* Falling only.. disable interrrupts on the rising edge */
+      /* Falling only.. disable interrupts on the rising edge */
 
       putreg32(pin, base + SAM_GPIO_IMR1S_OFFSET);
     }
diff --git a/nuttx/arch/arm/src/stm32/stm32_dumpgpio.c b/nuttx/arch/arm/src/stm32/stm32_dumpgpio.c
index 2e06a3eeb..06976956d 100644
--- a/nuttx/arch/arm/src/stm32/stm32_dumpgpio.c
+++ b/nuttx/arch/arm/src/stm32/stm32_dumpgpio.c
@@ -109,12 +109,10 @@ int stm32_dumpgpio(uint32_t pinset, const char *msg)
   irqstate_t   flags;
   uint32_t     base;
   unsigned int port;
-  unsigned int pin;
 
   /* Get the base address associated with the GPIO port */
 
   port = (pinset & GPIO_PORT_MASK) >> GPIO_PORT_SHIFT;
-  pin  = (pinset & GPIO_PIN_MASK) >> GPIO_PIN_SHIFT;
   base = g_gpiobase[port];
 
   /* The following requires exclusive access to the GPIO registers */
diff --git a/nuttx/arch/arm/src/str71x/str71x_serial.c b/nuttx/arch/arm/src/str71x/str71x_serial.c
index 2356898bb..2f4e56ff0 100644
--- a/nuttx/arch/arm/src/str71x/str71x_serial.c
+++ b/nuttx/arch/arm/src/str71x/str71x_serial.c
@@ -753,8 +753,10 @@ static int up_interrupt(int irq, void *context)
 
 static int up_ioctl(struct file *filep, int cmd, unsigned long arg)
 {
+#ifdef CONFIG_SERIAL_TIOCSERGSTRUCT
   struct inode      *inode = filep->f_inode;
   struct uart_dev_s *dev   = inode->i_private;
+#endif
   int                ret    = OK;
 
   switch (cmd)
diff --git a/nuttx/arch/avr/src/avr/up_checkstack.c b/nuttx/arch/avr/src/avr/up_checkstack.c
index 6ff0db083..07b1f9d14 100644
--- a/nuttx/arch/avr/src/avr/up_checkstack.c
+++ b/nuttx/arch/avr/src/avr/up_checkstack.c
@@ -82,7 +82,10 @@ size_t up_check_tcbstack(FAR struct tcb_s *tcb)
 {
   FAR uint8_t *ptr;
   size_t mark;
-  int i, j;
+#if 0
+  int i;
+  int j;
+#endif
 
   /* The AVR uses a push-down stack:  the stack grows toward lower addresses
    * in memory.  We need to start at the lowest address in the stack memory
@@ -121,8 +124,10 @@ size_t up_check_tcbstack(FAR struct tcb_s *tcb)
                 {
                   ch = 'X';
                 }
+
               up_putc(ch);
              }
+
           up_putc('\n');
         }
      }
diff --git a/nuttx/arch/hc/src/m9s12/m9s12_ethernet.c b/nuttx/arch/hc/src/m9s12/m9s12_ethernet.c
index 75c6f8ad7..d380f7757 100644
--- a/nuttx/arch/hc/src/m9s12/m9s12_ethernet.c
+++ b/nuttx/arch/hc/src/m9s12/m9s12_ethernet.c
@@ -291,7 +291,7 @@ static void emac_receive(FAR struct emac_driver_s *priv)
             }
         }
     }
-  while (); /* While there are more packets to be processed */
+  while (true); /* While there are more packets to be processed */
 }
 
 /****************************************************************************
diff --git a/nuttx/arch/sim/src/up_touchscreen.c b/nuttx/arch/sim/src/up_touchscreen.c
index f0d741760..c65013738 100644
--- a/nuttx/arch/sim/src/up_touchscreen.c
+++ b/nuttx/arch/sim/src/up_touchscreen.c
@@ -534,7 +534,7 @@ static int up_poll(FAR struct file *filep, FAR struct pollfd *fds,
 {
   FAR struct inode    *inode;
   FAR struct up_dev_s *priv;
-  int                  ret = OK;
+  int                  ret;
   int                  i;
 
   ivdbg("setup: %d\n", (int)setup);
diff --git a/nuttx/arch/z16/src/z16f/z16f_serial.c b/nuttx/arch/z16/src/z16f/z16f_serial.c
index 0d4e4876d..0b4468899 100644
--- a/nuttx/arch/z16/src/z16f/z16f_serial.c
+++ b/nuttx/arch/z16/src/z16f/z16f_serial.c
@@ -302,8 +302,7 @@ static uint8_t z16f_disableuartirq(struct uart_dev_s *dev)
 
 static void z16f_restoreuartirq(struct uart_dev_s *dev, uint8_t state)
 {
-  struct z16f_uart_s *priv  = (struct z16f_uart_s*)dev->priv;
-  irqstate_t          flags = irqsave();
+  irqstate_t flags = irqsave();
 
   z16f_txint(dev, (state & STATE_TXENABLED) ? true : false);
   z16f_rxint(dev, (state & STATE_RXENABLED) ? true : false);
@@ -400,7 +399,6 @@ static int z16f_setup(struct uart_dev_s *dev)
 
 static void z16f_shutdown(struct uart_dev_s *dev)
 {
-  struct z16f_uart_s *priv = (struct z16f_uart_s*)dev->priv;
   (void)z16f_disableuartirq(dev);
 }
 
diff --git a/nuttx/arch/z80/src/ez80/ez80_i2c.c b/nuttx/arch/z80/src/ez80/ez80_i2c.c
index 6668704dc..83942a542 100644
--- a/nuttx/arch/z80/src/ez80/ez80_i2c.c
+++ b/nuttx/arch/z80/src/ez80/ez80_i2c.c
@@ -393,7 +393,6 @@ static void i2c_stop(void)
 static int i2c_sendaddr(struct ez80_i2cdev_s *priv, uint8_t readbit)
 {
   uint8_t sr;
-  int ret = OK;
 
   /* Wait for the IFLG bit to transition to 1.  At this point, we should
    * have status == 8 meaning that the start bit was sent successfully.
diff --git a/nuttx/arch/z80/src/ez80/ez80_spi.c b/nuttx/arch/z80/src/ez80/ez80_spi.c
index 1cbe873f0..475c946a5 100644
--- a/nuttx/arch/z80/src/ez80/ez80_spi.c
+++ b/nuttx/arch/z80/src/ez80/ez80_spi.c
@@ -284,7 +284,7 @@ static uint8_t spi_waitspif(void)
  * Name: spi_transfer
  *
  * Description:
- *   Send one byte on SPI, return th response
+ *   Send one byte on SPI, return the response
  *
  * Input Parameters:
  *   ch - the byte to send
@@ -361,7 +361,7 @@ static void spi_sndblock(FAR struct spi_dev_s *dev, FAR const void *buffer,
   FAR const uint8_t *ptr = (FAR const uint8_t*)buffer;
   uint8_t response;
 
-  /* Loop while thre are bytes remaining to be sent */
+  /* Loop while there are bytes remaining to be sent */
 
   while (buflen-- > 0)
     {
@@ -392,7 +392,6 @@ static void spi_sndblock(FAR struct spi_dev_s *dev, FAR const void *buffer,
 static void spi_recvblock(FAR struct spi_dev_s *dev, FAR void *buffer, size_t buflen)
 {
   FAR uint8_t *ptr = (FAR uint8_t*)buffer;
-  uint8_t response;
 
   /* Loop while thre are bytes remaining to be sent */
 
diff --git a/nuttx/arch/z80/src/z180/z180_mmu.c b/nuttx/arch/z80/src/z180/z180_mmu.c
index 09fa65f21..d6ed1ebcf 100644
--- a/nuttx/arch/z80/src/z180/z180_mmu.c
+++ b/nuttx/arch/z80/src/z180/z180_mmu.c
@@ -438,7 +438,6 @@ int up_addrenv_destroy(task_addrenv_t addrenv)
 int up_addrenv_assign(task_addrenv_t addrenv, FAR struct tcb_s *tcb)
 {
   FAR struct z180_cbr_s *cbr = (FAR struct z180_cbr_s *)addrenv;
-  int ret;
 
   /* Make sure that there is no address environment in place on this TCB */
 
diff --git a/nuttx/arch/z80/src/z8/z8_serial.c b/nuttx/arch/z80/src/z8/z8_serial.c
index 553e3fb40..8e809988c 100644
--- a/nuttx/arch/z80/src/z8/z8_serial.c
+++ b/nuttx/arch/z80/src/z8/z8_serial.c
@@ -284,8 +284,7 @@ static uint8_t z8_disableuartirq(FAR struct uart_dev_s *dev)
 
 static void z8_restoreuartirq(FAR struct uart_dev_s *dev, uint8_t state)
 {
-  struct z8_uart_s *priv  = (struct z8_uart_s*)dev->priv;
-  irqstate_t          flags = irqsave();
+  irqstate_t flags = irqsave();
 
   z8_txint(dev, (state & STATE_TXENABLED) ? true : false);
   z8_rxint(dev, (state & STATE_RXENABLED) ? true : false);
@@ -322,8 +321,7 @@ static void z8_consoleput(uint8_t ch)
 
 void z8_uartconfigure(void)
 {
-  uint16_t brg;
-  uint8_t  val;
+  uint8_t val;
 
   /* Configure GPIO Port A pins 4 & 5 for alternate function */
 
@@ -421,7 +419,6 @@ static int z8_setup(FAR struct uart_dev_s *dev)
 
 static void z8_shutdown(FAR struct uart_dev_s *dev)
 {
-  struct z8_uart_s *priv = (struct z8_uart_s*)dev->priv;
   (void)z8_disableuartirq(dev);
 }
 
diff --git a/nuttx/binfmt/libelf/libelf_sections.c b/nuttx/binfmt/libelf/libelf_sections.c
index c41793544..236d7e9c8 100644
--- a/nuttx/binfmt/libelf/libelf_sections.c
+++ b/nuttx/binfmt/libelf/libelf_sections.c
@@ -124,12 +124,13 @@ static inline int elf_sectname(FAR struct elf_loadinfo_s *loadinfo,
       readlen = loadinfo->buflen - bytesread;
       if (offset + readlen > loadinfo->filelen)
         {
-          readlen = loadinfo->filelen - offset;
-          if (readlen <= 0)
+          if (loadinfo->filelen <= offset)
             {
               bdbg("At end of file\n");
               return -EINVAL;
             }
+
+          readlen = loadinfo->filelen - offset;
         }
 
       /* Read that number of bytes into the array */
diff --git a/nuttx/binfmt/libelf/libelf_symbols.c b/nuttx/binfmt/libelf/libelf_symbols.c
index 2d94b11af..bd7942a67 100644
--- a/nuttx/binfmt/libelf/libelf_symbols.c
+++ b/nuttx/binfmt/libelf/libelf_symbols.c
@@ -110,12 +110,13 @@ static int elf_symname(FAR struct elf_loadinfo_s *loadinfo,
       readlen = loadinfo->buflen - bytesread;
       if (offset + readlen > loadinfo->filelen)
         {
-          readlen = loadinfo->filelen - offset;
-          if (readlen <= 0)
+          if (loadinfo->filelen <= offset)
             {
               bdbg("At end of file\n");
               return -EINVAL;
             }
+
+          readlen = loadinfo->filelen - offset;
         }
 
       /* Read that number of bytes into the array */
diff --git a/nuttx/binfmt/libnxflat/libnxflat_init.c b/nuttx/binfmt/libnxflat/libnxflat_init.c
index b7cac8d86..add645b54 100644
--- a/nuttx/binfmt/libnxflat/libnxflat_init.c
+++ b/nuttx/binfmt/libnxflat/libnxflat_init.c
@@ -97,7 +97,6 @@ int nxflat_init(const char *filename, struct nxflat_loadinfo_s *loadinfo)
 {
   uint32_t datastart;
   uint32_t dataend;
-  uint32_t bssstart;
   uint32_t bssend;
   int      ret;
 
@@ -152,7 +151,6 @@ int nxflat_init(const char *filename, struct nxflat_loadinfo_s *loadinfo)
 
   datastart             = ntohl(loadinfo->header.h_datastart);
   dataend               = ntohl(loadinfo->header.h_dataend);
-  bssstart              = dataend;
   bssend                = ntohl(loadinfo->header.h_bssend);
 
   /* And put this information into the loadinfo structure as well.
diff --git a/nuttx/configs/lpc4330-xplorer/src/up_nsh.c b/nuttx/configs/lpc4330-xplorer/src/up_nsh.c
index 3a7fa83cd..df1f0ddf7 100644
--- a/nuttx/configs/lpc4330-xplorer/src/up_nsh.c
+++ b/nuttx/configs/lpc4330-xplorer/src/up_nsh.c
@@ -103,7 +103,7 @@ static int nsh_spifi_initialize(void)
       return ret;
     }
 #else
-  /* Initialize to provide NXFFS on the MTD interface */1G
+  /* Initialize to provide NXFFS on the MTD interface */
 
   ret = nxffs_initialize(mtd);
   if (ret < 0)
diff --git a/nuttx/configs/mikroe-stm32f4/src/up_clockconfig.c b/nuttx/configs/mikroe-stm32f4/src/up_clockconfig.c
index 3c55bd950..8950147ee 100644
--- a/nuttx/configs/mikroe-stm32f4/src/up_clockconfig.c
+++ b/nuttx/configs/mikroe-stm32f4/src/up_clockconfig.c
@@ -109,7 +109,7 @@ void stm32_board_clockconfig(void)
   regval |= STM32_RCC_CFGR_PPRE1;
   putreg32(regval, STM32_RCC_CFGR);
 
-  /* Set the PLL dividers and multiplers to configure the main PLL */
+  /* Set the PLL dividers and multipliers to configure the main PLL */
 
   regval = (STM32_PLLCFG_PLLM | STM32_PLLCFG_PLLN |STM32_PLLCFG_PLLP |
             RCC_PLLCFG_PLLSRC_HSI | STM32_PLLCFG_PLLQ);
diff --git a/nuttx/configs/mikroe-stm32f4/src/up_nsh.c b/nuttx/configs/mikroe-stm32f4/src/up_nsh.c
index b8be4a4a7..844389e93 100644
--- a/nuttx/configs/mikroe-stm32f4/src/up_nsh.c
+++ b/nuttx/configs/mikroe-stm32f4/src/up_nsh.c
@@ -181,9 +181,6 @@
 
 int nsh_archinitialize(void)
 {
-#if defined(HAVE_USBHOST) || defined(HAVE_USBMONITOR)
-  int ret;
-#endif
 #ifdef CONFIG_STM32_SPI3
   FAR struct spi_dev_s *spi;
   FAR struct mtd_dev_s *mtd;
diff --git a/nuttx/configs/mx1ads/src/up_boot.c b/nuttx/configs/mx1ads/src/up_boot.c
index 67ac4ce17..6d7576d0c 100644
--- a/nuttx/configs/mx1ads/src/up_boot.c
+++ b/nuttx/configs/mx1ads/src/up_boot.c
@@ -81,7 +81,7 @@ void imx_boardinitialize(void)
             (IMX_CSCR_USBDIV << PLL_CSCR_USBDIV_SHIFT) |    /* USB divider */
             CSCR_SDCNT_4thEDGE |                            /* Shutdown on 4th edge */
             (IMX_CSCR_BCLKDIV << PLL_CSCR_BCLKDIV_SHIFT) |  /* Bclock divider */
-	    PLL_CSCR_SPEN | PLL_CSCR_MPEN);                /* Enable MUC and System PLL */
+             PLL_CSCR_SPEN | PLL_CSCR_MPEN);                /* Enable MUC and System PLL */
   putreg32(regval, IMX_PLL_CSCR);
 
   /* Use these new frequencies now */
diff --git a/nuttx/configs/olimex-strp711/src/up_nsh.c b/nuttx/configs/olimex-strp711/src/up_nsh.c
index e10372310..693a51d2a 100644
--- a/nuttx/configs/olimex-strp711/src/up_nsh.c
+++ b/nuttx/configs/olimex-strp711/src/up_nsh.c
@@ -125,11 +125,10 @@
 
 int nsh_archinitialize(void)
 {
+#ifdef NSH_HAVEMMCSD
   FAR struct spi_dev_s *spi;
   int ret;
 
-#ifdef NSH_HAVEMMCSD
-
   /* Get the SPI port */
 
   message("nsh_archinitialize: Initializing SPI port %d\n",
diff --git a/nuttx/configs/pic32mx7mmb/src/up_touchscreen.c b/nuttx/configs/pic32mx7mmb/src/up_touchscreen.c
index 7babc6194..2f1bce713 100644
--- a/nuttx/configs/pic32mx7mmb/src/up_touchscreen.c
+++ b/nuttx/configs/pic32mx7mmb/src/up_touchscreen.c
@@ -1365,9 +1365,6 @@ int arch_tcinitialize(int minor)
 {
   FAR struct tc_dev_s *priv;
   char devname[DEV_NAMELEN];
-#ifdef CONFIG_TOUCHSCREEN_MULTIPLE
-  irqstate_t flags;
-#endif
   int ret;
 
   ivdbg("minor: %d\n", minor);
diff --git a/nuttx/configs/px4fmu-v2_upstream/src/px4fmu2_init.c b/nuttx/configs/px4fmu-v2_upstream/src/px4fmu2_init.c
index 5b6537591..4d13cda10 100644
--- a/nuttx/configs/px4fmu-v2_upstream/src/px4fmu2_init.c
+++ b/nuttx/configs/px4fmu-v2_upstream/src/px4fmu2_init.c
@@ -195,7 +195,9 @@ void stm32_boardinitialize(void)
 
 int nsh_archinitialize(void)
 {
+#ifdef CONFIG_MMCSD
   int ret;
+#endif
 
   /* Configure ADC pins */
 
diff --git a/nuttx/configs/sam4l-xplained/src/sam_buttons.c b/nuttx/configs/sam4l-xplained/src/sam_buttons.c
index e06f476fc..2d6175652 100644
--- a/nuttx/configs/sam4l-xplained/src/sam_buttons.c
+++ b/nuttx/configs/sam4l-xplained/src/sam_buttons.c
@@ -147,6 +147,7 @@ xcpt_t board_button_irq(int id, xcpt_t irqhandler)
       sam_gpioirq(IRQ_SW0);
       (void)irq_attach(IRQ_SW0, irqhandler);
       sam_gpioirqenable(IRQ_SW0);
+      irqrestore(flags);
     }
 
   /* Return the old button handler (so that it can be restored) */
diff --git a/nuttx/configs/sam4s-xplained/src/sam_buttons.c b/nuttx/configs/sam4s-xplained/src/sam_buttons.c
index f072440fc..ce7e68e61 100644
--- a/nuttx/configs/sam4s-xplained/src/sam_buttons.c
+++ b/nuttx/configs/sam4s-xplained/src/sam_buttons.c
@@ -145,6 +145,7 @@ xcpt_t board_button_irq(int id, xcpt_t irqhandler)
       sam_gpioirq(IRQ_BP2);
       (void)irq_attach(IRQ_BP2, irqhandler);
       sam_gpioirqenable(IRQ_BP2);
+      irqrestore(flags);
     }
 
   /* Return the old button handler (so that it can be restored) */
diff --git a/nuttx/configs/skp16c26/src/up_lcd.c b/nuttx/configs/skp16c26/src/up_lcd.c
index a47f4af51..75beec8c4 100644
--- a/nuttx/configs/skp16c26/src/up_lcd.c
+++ b/nuttx/configs/skp16c26/src/up_lcd.c
@@ -116,6 +116,7 @@ static inline void up_setrs(bool data)
     {
       regval &= ~(1 << 0); /* Low = control */
     }
+
   putreg8(regval, M16C_P6);
 }
 
@@ -128,7 +129,7 @@ static inline void up_seten(void)
   /* Set bit 1 of port 6 */
 
   register uint8_t regval = getreg8(M16C_P6);
-  regval = (1 << 1);
+  regval |= (1 << 1);
   putreg8(regval, M16C_P6);
 }
 
diff --git a/nuttx/configs/stm32ldiscovery/src/stm32_nsh.c b/nuttx/configs/stm32ldiscovery/src/stm32_nsh.c
index 63c29c5dc..bd633b659 100644
--- a/nuttx/configs/stm32ldiscovery/src/stm32_nsh.c
+++ b/nuttx/configs/stm32ldiscovery/src/stm32_nsh.c
@@ -82,13 +82,11 @@
 
 int nsh_archinitialize(void)
 {
-  int ret = OK;
-
+#ifdef CONFIG_STM32_LCD
   /* Initialize the SLCD and register the SLCD device as /dev/slcd */
 
-#ifdef CONFIG_STM32_LCD
-  ret = stm32_slcd_initialize();
+  return stm32_slcd_initialize();
+#else
+  return OK;
 #endif
-
-  return ret;
 }
diff --git a/nuttx/configs/twr-k60n512/src/up_buttons.c b/nuttx/configs/twr-k60n512/src/up_buttons.c
index 4bd6b7adf..7e1459d8a 100644
--- a/nuttx/configs/twr-k60n512/src/up_buttons.c
+++ b/nuttx/configs/twr-k60n512/src/up_buttons.c
@@ -135,7 +135,7 @@ uint8_t board_buttons(void)
 #ifdef CONFIG_ARCH_IRQBUTTONS
 xcpt_t board_button_irq(int id, xcpt_t irqhandler)
 {
-  xcpt_t oldhandler = NULL;
+  xcpt_t oldhandler;
   uint32_t pinset;
 
   /* Map the button id to the GPIO bit set. */
diff --git a/nuttx/configs/us7032evb1/shterm/shterm.c b/nuttx/configs/us7032evb1/shterm/shterm.c
index f9ff2994a..361f134ff 100644
--- a/nuttx/configs/us7032evb1/shterm/shterm.c
+++ b/nuttx/configs/us7032evb1/shterm/shterm.c
@@ -110,6 +110,7 @@ static void putconsole(char ch)
     {
       (void)putc(ch, g_logstream);
     }
+
   (void)putchar(ch);
 }
 
@@ -139,6 +140,7 @@ static void printconsole(const char *fmt, ...)
     {
       (void)vfprintf(g_logstream, fmt, ap);
     }
+
   (void)vprintf(fmt, ap);
   va_end(ap);
 }
@@ -435,7 +437,7 @@ static void close_tty(void)
       (void)close(g_fd);
     }
 
-  if (g_logstream >= 0)
+  if (g_logstream)
     {
       (void)fclose(g_logstream);
     }
@@ -717,7 +719,7 @@ int main(int argc, char **argv, char **envp)
                 {
                   sendfile(g_fd, filename, 0);
                 }
-              else if (ch1 == 'v' || ch1 == 'v')
+              else if (ch1 == 'v' || ch1 == 'V')
                 {
                   sendfile(g_fd, filename, 1);
                 }
diff --git a/nuttx/drivers/analog/adc.c b/nuttx/drivers/analog/adc.c
index 5b02efa96..a03507cb8 100644
--- a/nuttx/drivers/analog/adc.c
+++ b/nuttx/drivers/analog/adc.c
@@ -362,9 +362,9 @@ static ssize_t adc_write(FAR struct file *filep, FAR const char *buffer, size_t
 
 static int adc_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 {
-  FAR struct inode     *inode = filep->f_inode;
-  FAR struct adc_dev_s *dev   = inode->i_private;
-  int               ret   = OK;
+  FAR struct inode *inode = filep->f_inode;
+  FAR struct adc_dev_s *dev = inode->i_private;
+  int ret;
 
   ret = dev->ad_ops->ao_ioctl(dev, cmd, arg);
   return ret;
diff --git a/nuttx/drivers/analog/ads1255.c b/nuttx/drivers/analog/ads1255.c
index 525e3cb7f..6402a9166 100644
--- a/nuttx/drivers/analog/ads1255.c
+++ b/nuttx/drivers/analog/ads1255.c
@@ -107,14 +107,14 @@
 
 struct up_dev_s
 {
-    uint8_t channel;
-    uint32_t sps;
-    uint8_t pga;
-    uint8_t buf;
-    const uint8_t *mux;
-    int irq;
-    int devno;
-    FAR struct spi_dev_s  *spi;      /* Cached SPI device reference */
+  uint8_t channel;
+  uint32_t sps;
+  uint8_t pga;
+  uint8_t buf;
+  const uint8_t *mux;
+  int irq;
+  int devno;
+  FAR struct spi_dev_s *spi;      /* Cached SPI device reference */
 };
 
 /****************************************************************************
@@ -136,28 +136,28 @@ static int  adc_interrupt(int irq, void *context);
 
 static const struct adc_ops_s g_adcops =
 {
-    .ao_reset = adc_reset,     /* ao_reset */
-    .ao_setup = adc_setup,     /* ao_setup */
-    .ao_shutdown = adc_shutdown,  /* ao_shutdown */
-    .ao_rxint = adc_rxint,     /* ao_rxint */
-    .ao_ioctl = adc_ioctl      /* ao_read */
+  .ao_reset = adc_reset,        /* ao_reset */
+  .ao_setup = adc_setup,        /* ao_setup */
+  .ao_shutdown = adc_shutdown,  /* ao_shutdown */
+  .ao_rxint = adc_rxint,        /* ao_rxint */
+  .ao_ioctl = adc_ioctl         /* ao_read */
 };
 
 static struct up_dev_s g_adcpriv =
 {
-    .mux  = (const uint8_t [])
-    {
-        CONFIG_ADS1255_MUX,0
-    },
-    .sps  = CONFIG_ADS1255_SPS,
-    .channel = 0,
-    .irq  = CONFIG_ADS1255_IRQ,
+  .mux  = (const uint8_t [])
+  {
+    CONFIG_ADS1255_MUX,0
+  },
+  .sps  = CONFIG_ADS1255_SPS,
+  .channel = 0,
+  .irq  = CONFIG_ADS1255_IRQ,
 };
 
 static struct adc_dev_s g_adcdev =
 {
-    .ad_ops = &g_adcops,
-    .ad_priv= &g_adcpriv,
+  .ad_ops = &g_adcops,
+  .ad_priv= &g_adcpriv,
 };
 
 /****************************************************************************
@@ -166,141 +166,155 @@ static struct adc_dev_s g_adcdev =
 
 static uint8_t getspsreg(uint16_t sps)
 {
-    static const unsigned short sps_tab[]=
-    {
-        3,7,12,20,27,40,55,80,300,750,1500,3000,5000,10000,20000,65535,
-    };
-    static const unsigned char sps_reg[]=
-    {
-        0x03,0x13,0x23,0x33,0x43,0x53,0x63,0x72,0x82,0x92,0xa1,0xb0,0xc0,0xd0,0xe0,0xf0,
-    };
-    int i;
-    for (i=0; i<16; i++)
+  static const unsigned short sps_tab[]=
+  {
+    3,7,12,20,27,40,55,80,300,750,1500,3000,5000,10000,20000,65535,
+  };
+  static const unsigned char sps_reg[]=
+  {
+    0x03,0x13,0x23,0x33,0x43,0x53,0x63,0x72,0x82,0x92,0xa1,0xb0,0xc0,0xd0,0xe0,0xf0,
+  };
+  int i;
+
+  for (i=0; i<16; i++)
     {
-        if (sps<sps_tab[i])
-            break;
+      if (sps<sps_tab[i])
+        {
+          break;
+        }
     }
-    return sps_reg[i];
+
+  return sps_reg[i];
 }
 
 /****************************************************************************
  * ad_private Functions
  ****************************************************************************/
 /* Reset the ADC device.  Called early to initialize the hardware. This
-* is called, before ao_setup() and on error conditions.
-*/
+ * is called, before ao_setup() and on error conditions.
+ */
 
 static void adc_reset(FAR struct adc_dev_s *dev)
 {
-    FAR struct up_dev_s *priv = (FAR struct up_dev_s *)dev->ad_priv;
-    FAR struct spi_dev_s *spi = priv->spi;
-
-    SPI_SETMODE(spi, SPIDEV_MODE1);
-    SPI_SETBITS(spi, 8);
-    SPI_SETFREQUENCY(spi, CONFIG_ADS1255_FREQUENCY);
-    usleep(1000);
-    SPI_SELECT(spi, priv->devno, true);
-    SPI_SEND(spi,ADS125X_WREG+0x03);    //WRITE SPS REG
-    SPI_SEND(spi,0x00);                 //count=1
-    SPI_SEND(spi,0x63);
-    SPI_SELECT(spi, priv->devno, false);
+  FAR struct up_dev_s *priv = (FAR struct up_dev_s *)dev->ad_priv;
+  FAR struct spi_dev_s *spi = priv->spi;
+
+  SPI_SETMODE(spi, SPIDEV_MODE1);
+  SPI_SETBITS(spi, 8);
+  SPI_SETFREQUENCY(spi, CONFIG_ADS1255_FREQUENCY);
+  usleep(1000);
+  SPI_SELECT(spi, priv->devno, true);
+  SPI_SEND(spi,ADS125X_WREG+0x03);    /* WRITE SPS REG */
+  SPI_SEND(spi,0x00);                 /* count=1 */
+  SPI_SEND(spi,0x63);
+  SPI_SELECT(spi, priv->devno, false);
 }
 
 /* Configure the ADC. This method is called the first time that the ADC
-* device is opened.  This will occur when the port is first opened.
-* This setup includes configuring and attaching ADC interrupts.  Interrupts
-* are all disabled upon return.
-*/
+ * device is opened.  This will occur when the port is first opened.
+ * This setup includes configuring and attaching ADC interrupts.  Interrupts
+ * are all disabled upon return.
+ */
 
 static int  adc_setup(FAR struct adc_dev_s *dev)
 {
-    FAR struct up_dev_s *priv = (FAR struct up_dev_s *)dev->ad_priv;
-    FAR struct spi_dev_s *spi = priv->spi;
-    int ret = irq_attach(priv->irq, adc_interrupt);
-    if (ret == OK)
+  FAR struct up_dev_s *priv = (FAR struct up_dev_s *)dev->ad_priv;
+  FAR struct spi_dev_s *spi = priv->spi;
+  int ret = irq_attach(priv->irq, adc_interrupt);
+
+  if (ret == OK)
     {
-        SPI_SELECT(spi, priv->devno, true);
-        SPI_SEND(spi,ADS125X_WREG);         //WRITE REG from 0
-        SPI_SEND(spi,0x03);                 //count=4+1
-        if (priv->buf)
-            SPI_SEND(spi,ADS125X_BUFON);    //REG0 STATUS BUFFER ON
-        else
-            SPI_SEND(spi,ADS125X_BUFOFF);
-        SPI_SEND(spi,priv->mux[0]);
-        SPI_SEND(spi,priv->pga);            //REG2 ADCON PGA=2
-        SPI_SEND(spi,getspsreg(priv->sps));
-        usleep(1000);
-        SPI_SEND(spi,ADS125X_SELFCAL);
-        SPI_SELECT(spi, priv->devno, false);
-        up_enable_irq(priv->irq);
+      SPI_SELECT(spi, priv->devno, true);
+      SPI_SEND(spi,ADS125X_WREG);         /* WRITE REG from 0 */
+      SPI_SEND(spi,0x03);                 /* count=4+1 */
+      if (priv->buf)
+        {
+          SPI_SEND(spi,ADS125X_BUFON);    /* REG0 STATUS BUFFER ON */
+        }
+      else
+        {
+          SPI_SEND(spi,ADS125X_BUFOFF);
+        }
+
+      SPI_SEND(spi,priv->mux[0]);
+      SPI_SEND(spi,priv->pga);            /* REG2 ADCON PGA=2 */
+      SPI_SEND(spi,getspsreg(priv->sps));
+      usleep(1000);
+      SPI_SEND(spi,ADS125X_SELFCAL);
+      SPI_SELECT(spi, priv->devno, false);
+      up_enable_irq(priv->irq);
     }
-    return ret;
+
+  return ret;
 }
 
 /* Disable the ADC.  This method is called when the ADC device is closed.
-* This method reverses the operation the setup method.
-*/
+ * This method reverses the operation the setup method.
+ */
 
 static void adc_shutdown(FAR struct adc_dev_s *dev)
 {
-    FAR struct up_dev_s *priv = (FAR struct up_dev_s *)dev->ad_priv;
-    up_disable_irq(priv->irq);
-    irq_detach(priv->irq);
+  FAR struct up_dev_s *priv = (FAR struct up_dev_s *)dev->ad_priv;
+  up_disable_irq(priv->irq);
+  irq_detach(priv->irq);
 }
 
 /* Call to enable or disable RX interrupts */
 
 static void adc_rxint(FAR struct adc_dev_s *dev, bool enable)
 {
-    FAR struct up_dev_s *priv = (FAR struct up_dev_s *)dev->ad_priv;
-    if (enable)
-        up_enable_irq(priv->irq);
-    else
-        up_disable_irq(priv->irq);
+  FAR struct up_dev_s *priv = (FAR struct up_dev_s *)dev->ad_priv;
+  if (enable)
+    {
+      up_enable_irq(priv->irq);
+    }
+  else
+    {
+      up_disable_irq(priv->irq);
+    }
 }
 
 /* All ioctl calls will be routed through this method */
 
 static int  adc_ioctl(FAR struct adc_dev_s *dev, int cmd, unsigned long arg)
 {
-    dbg("Fix me:Not Implemented\n");
-    return 0;
+  dbg("Fix me:Not Implemented\n");
+  return 0;
 }
 
 static int adc_interrupt(int irq, void *context)
 {
-    uint32_t regval;
-    FAR struct up_dev_s *priv = (FAR struct up_dev_s *)g_adcdev.ad_priv;
-    FAR struct spi_dev_s *spi = priv->spi;
-    unsigned char buf[4];
-    unsigned char ch;
-
-    SPI_SELECT(spi, priv->devno, true);
-    SPI_SEND(spi,ADS125X_RDATA);
-    up_udelay(10);
-    buf[3]=SPI_SEND(spi,0xff);
-    buf[2]=SPI_SEND(spi,0xff);
-    buf[1]=SPI_SEND(spi,0xff);
-    buf[0]=0;
-
-    priv->channel++;
-    ch = priv->mux[priv->channel];
-    if ( ch == 0 )
+  FAR struct up_dev_s *priv = (FAR struct up_dev_s *)g_adcdev.ad_priv;
+  FAR struct spi_dev_s *spi = priv->spi;
+  unsigned char buf[4];
+  unsigned char ch;
+
+  SPI_SELECT(spi, priv->devno, true);
+  SPI_SEND(spi,ADS125X_RDATA);
+  up_udelay(10);
+  buf[3]=SPI_SEND(spi,0xff);
+  buf[2]=SPI_SEND(spi,0xff);
+  buf[1]=SPI_SEND(spi,0xff);
+  buf[0]=0;
+
+  priv->channel++;
+  ch = priv->mux[priv->channel];
+  if ( ch == 0 )
     {
-        priv->channel=0;
-        ch = priv->mux[0];
+      priv->channel=0;
+      ch = priv->mux[0];
     }
 
-    SPI_SEND(spi,ADS125X_WREG+0x01);
-    SPI_SEND(spi,0x00);
-    SPI_SEND(spi,ch);
-    SPI_SEND(spi,ADS125X_SYNC);
-    up_udelay(2);
-    SPI_SEND(spi,ADS125X_WAKEUP);
-    SPI_SELECT(spi, priv->devno, false);
+  SPI_SEND(spi,ADS125X_WREG+0x01);
+  SPI_SEND(spi,0x00);
+  SPI_SEND(spi,ch);
+  SPI_SEND(spi,ADS125X_SYNC);
+  up_udelay(2);
+  SPI_SEND(spi,ADS125X_WAKEUP);
+  SPI_SELECT(spi, priv->devno, false);
 
-    adc_receive(&g_adcdev,priv->channel,*(int32_t *)buf);
-    return OK;
+  adc_receive(&g_adcdev,priv->channel,*(int32_t *)buf);
+  return OK;
 }
 
 /****************************************************************************
@@ -323,13 +337,13 @@ static int adc_interrupt(int irq, void *context)
 
 FAR struct adc_dev_s *up_ads1255initialize(FAR struct spi_dev_s *spi, unsigned int devno)
 {
-    FAR struct up_dev_s *priv = (FAR struct up_dev_s *)g_adcdev.ad_priv;
+  FAR struct up_dev_s *priv = (FAR struct up_dev_s *)g_adcdev.ad_priv;
 
-    /* Driver state data */
+  /* Driver state data */
 
-    priv->spi      = spi;
-    priv->devno    = devno;
-    return &g_adcdev;
+  priv->spi      = spi;
+  priv->devno    = devno;
+  return &g_adcdev;
 }
 #endif
 
diff --git a/nuttx/drivers/analog/dac.c b/nuttx/drivers/analog/dac.c
index e1fc3049f..31d1242e7 100644
--- a/nuttx/drivers/analog/dac.c
+++ b/nuttx/drivers/analog/dac.c
@@ -68,7 +68,6 @@
 #define HALF_SECOND_MSEC 500
 #define HALF_SECOND_USEC 500000L
 
-
 /****************************************************************************
  * Private Function Prototypes
  ****************************************************************************/
@@ -155,11 +154,14 @@ static int dac_open(FAR struct file *filep)
 
                   dev->ad_ocount = tmp;
                 }
+
               irqrestore(flags);
             }
         }
+
       sem_post(&dev->ad_closesem);
     }
+
   return ret;
 }
 
@@ -220,6 +222,7 @@ static int dac_close(FAR struct file *filep)
           sem_post(&dev->ad_closesem);
         }
     }
+
   return ret;
 }
 
@@ -260,6 +263,7 @@ static int dac_xmit(FAR struct dac_dev_s *dev)
 
       enable = (ret == OK ? true : false);
     }
+
   dev->ad_ops->ao_txint(dev, enable);
   return ret;
 }
@@ -274,7 +278,7 @@ static ssize_t dac_write(FAR struct file *filep, FAR const char *buffer, size_t
   FAR struct dac_dev_s  *dev   = inode->i_private;
   FAR struct dac_fifo_s *fifo  = &dev->ad_xmit;
   FAR struct dac_msg_s  *msg;
-  bool                   empty = false;
+  bool                   empty;
   ssize_t                nsent = 0;
   irqstate_t             flags;
   int                    nexttail;
@@ -295,18 +299,30 @@ static ssize_t dac_write(FAR struct file *filep, FAR const char *buffer, size_t
    * shorter than the minimum.
    */
 
-  if (buflen % 5 ==0 )
-    msglen=5;
-  else if (buflen % 4 ==0 )
-    msglen=4;
-  else if (buflen % 3 ==0 )
-    msglen=3;
-  else if (buflen % 2 ==0 )
-    msglen=2;
+  if (buflen % 5 == 0 )
+    {
+      msglen = 5;
+    }
+  else if (buflen % 4 == 0)
+    {
+      msglen = 4;
+    }
+  else if (buflen % 3 == 0)
+    {
+      msglen = 3;
+    }
+  else if (buflen % 2 == 0)
+    {
+      msglen = 2;
+    }
   else if (buflen == 1)
-    msglen=1;
+    {
+      msglen = 1;
+    }
   else
-    msglen=5;
+    {
+      msglen = 5;
+    }
 
   while ((buflen - nsent) >= msglen )
     {
@@ -336,6 +352,7 @@ static ssize_t dac_write(FAR struct file *filep, FAR const char *buffer, size_t
                 {
                   ret = nsent;
                 }
+
               goto return_with_irqdisabled;
             }
 
@@ -370,35 +387,36 @@ static ssize_t dac_write(FAR struct file *filep, FAR const char *buffer, size_t
        * CAN message at the tail of the FIFO.
        */
 
-     if (msglen==5)
-     {
-        msg    = (FAR struct dac_msg_s *)&buffer[nsent];
-        memcpy(&fifo->af_buffer[fifo->af_tail], msg, msglen);
-     }
-     else if(msglen == 4)
-     {
-         fifo->af_buffer[fifo->af_tail].am_channel=buffer[nsent];
-         fifo->af_buffer[fifo->af_tail].am_data=*(uint32_t *)&buffer[nsent];
-         fifo->af_buffer[fifo->af_tail].am_data&=0xffffff00;
-     }
-     else if(msglen == 3)
-     {
-         fifo->af_buffer[fifo->af_tail].am_channel=buffer[nsent];
-         fifo->af_buffer[fifo->af_tail].am_data=(*(uint16_t *)&buffer[nsent+1]);
-         fifo->af_buffer[fifo->af_tail].am_data<<=16;
-     }
-     else if(msglen == 2)
-     {
-         fifo->af_buffer[fifo->af_tail].am_channel=0;
-         fifo->af_buffer[fifo->af_tail].am_data=(*(uint16_t *)&buffer[nsent]);
-         fifo->af_buffer[fifo->af_tail].am_data<<=16;
-     }
-     else if(msglen == 1)
-     {
-         fifo->af_buffer[fifo->af_tail].am_channel=0;
-         fifo->af_buffer[fifo->af_tail].am_data=buffer[nsent];
-         fifo->af_buffer[fifo->af_tail].am_data<<=24;
-     }
+      if (msglen == 5)
+        {
+          msg = (FAR struct dac_msg_s *)&buffer[nsent];
+          memcpy(&fifo->af_buffer[fifo->af_tail], msg, msglen);
+        }
+      else if (msglen == 4)
+        {
+          fifo->af_buffer[fifo->af_tail].am_channel=buffer[nsent];
+          fifo->af_buffer[fifo->af_tail].am_data=*(uint32_t *)&buffer[nsent];
+          fifo->af_buffer[fifo->af_tail].am_data&=0xffffff00;
+        }
+      else if(msglen == 3)
+        {
+          fifo->af_buffer[fifo->af_tail].am_channel=buffer[nsent];
+          fifo->af_buffer[fifo->af_tail].am_data=(*(uint16_t *)&buffer[nsent+1]);
+          fifo->af_buffer[fifo->af_tail].am_data<<=16;
+        }
+      else if(msglen == 2)
+        {
+          fifo->af_buffer[fifo->af_tail].am_channel=0;
+          fifo->af_buffer[fifo->af_tail].am_data=(*(uint16_t *)&buffer[nsent]);
+          fifo->af_buffer[fifo->af_tail].am_data<<=16;
+        }
+      else if(msglen == 1)
+       {
+          fifo->af_buffer[fifo->af_tail].am_channel=0;
+          fifo->af_buffer[fifo->af_tail].am_data=buffer[nsent];
+          fifo->af_buffer[fifo->af_tail].am_data<<=24;
+       }
+
       /* Increment the tail of the circular buffer */
 
       fifo->af_tail = nexttail;
@@ -432,9 +450,9 @@ return_with_irqdisabled:
 
 static int dac_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 {
-  FAR struct inode     *inode = filep->f_inode;
-  FAR struct dac_dev_s *dev   = inode->i_private;
-  int               ret   = OK;
+  FAR struct inode *inode = filep->f_inode;
+  FAR struct dac_dev_s *dev = inode->i_private;
+  int ret;
 
   ret = dev->ad_ops->ao_ioctl(dev, cmd, arg);
   return ret;
@@ -480,6 +498,7 @@ int dac_txdone(FAR struct dac_dev_s *dev)
           ret = sem_post(&dev->ad_xmit.af_sem);
         }
     }
+
   return ret;
 }
 
@@ -496,4 +515,3 @@ int dac_register(FAR const char *path, FAR struct dac_dev_s *dev)
 
   return register_driver(path, &dac_fops, 0555, dev);
 }
-
diff --git a/nuttx/drivers/audio/vs1053.c b/nuttx/drivers/audio/vs1053.c
index e44c7a6e4..e7b7cc059 100644
--- a/nuttx/drivers/audio/vs1053.c
+++ b/nuttx/drivers/audio/vs1053.c
@@ -1255,9 +1255,12 @@ static void *vs1053_workerthread(pthread_addr_t pvarg)
 {
   FAR struct vs1053_struct_s *dev = (struct vs1053_struct_s *) pvarg;
   struct audio_msg_s      msg;
-  FAR struct ap_buffer_s  *pBuf;
-  int                     size, prio;
+  FAR struct ap_buffer_s *pBuf;
+  int                     size;
+  int                     prio;
+#ifndef CONFIG_AUDIO_EXCLUDE_STOP
   uint16_t                reg;
+#endif
   uint8_t                 timeout;
 
   auddbg("Entry\n");
@@ -1454,7 +1457,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 = sem_wait(&dev->apbq_sem)) == OK)
     {
       dev->pBuf = (FAR struct ap_buffer_s *) dq_remfirst(&dev->apbq);
       apb_reference(dev->pBuf);               /* Add our buffer reference */
diff --git a/nuttx/drivers/input/ads7843e.c b/nuttx/drivers/input/ads7843e.c
index 245b8b2d3..4fd2f43a6 100644
--- a/nuttx/drivers/input/ads7843e.c
+++ b/nuttx/drivers/input/ads7843e.c
@@ -1080,10 +1080,10 @@ static int ads7843e_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 static int ads7843e_poll(FAR struct file *filep, FAR struct pollfd *fds,
                         bool setup)
 {
-  FAR struct inode         *inode;
+  FAR struct inode *inode;
   FAR struct ads7843e_dev_s *priv;
-  int                       ret = OK;
-  int                       i;
+  int ret;
+  int i;
 
   ivdbg("setup: %d\n", (int)setup);
   DEBUGASSERT(filep && fds);
diff --git a/nuttx/drivers/input/max11802.c b/nuttx/drivers/input/max11802.c
index ebb261833..bce72ed46 100644
--- a/nuttx/drivers/input/max11802.c
+++ b/nuttx/drivers/input/max11802.c
@@ -1061,12 +1061,10 @@ static int max11802_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 static int max11802_poll(FAR struct file *filep, FAR struct pollfd *fds,
                         bool setup)
 {
-  FAR struct inode         *inode;
+  FAR struct inode *inode;
   FAR struct max11802_dev_s *priv;
-  pollevent_t               eventset;
-  int                       ndx;
-  int                       ret = OK;
-  int                       i;
+  int ret;
+  int i;
 
   ivdbg("setup: %d\n", (int)setup);
   DEBUGASSERT(filep && fds);
diff --git a/nuttx/drivers/input/stmpe811_gpio.c b/nuttx/drivers/input/stmpe811_gpio.c
index b545828d1..7c75e402e 100644
--- a/nuttx/drivers/input/stmpe811_gpio.c
+++ b/nuttx/drivers/input/stmpe811_gpio.c
@@ -381,7 +381,7 @@ int stmpe811_gpioattach(STMPE811_HANDLE handle, uint8_t pinconfig,
     {
       /* Enable interrupts for this GPIO */
 
-      regval &= ~GPIO_PIN(pin);
+      regval |= GPIO_PIN(pin);
     }
   else
     {
@@ -389,6 +389,7 @@ int stmpe811_gpioattach(STMPE811_HANDLE handle, uint8_t pinconfig,
 
       regval &= ~GPIO_PIN(pin);
     }
+
   stmpe811_putreg8(priv, STMPE811_GPIO_EN, regval);
 
   sem_post(&priv->exclsem);
diff --git a/nuttx/drivers/input/stmpe811_tsc.c b/nuttx/drivers/input/stmpe811_tsc.c
index 29f394b68..3c8cc659a 100644
--- a/nuttx/drivers/input/stmpe811_tsc.c
+++ b/nuttx/drivers/input/stmpe811_tsc.c
@@ -769,7 +769,7 @@ static void stmpe811_timeout(int argc, uint32_t arg1, ...)
 
   /* Are we still stuck in the pen down state? */
 
-  if (priv->sample.contact == CONTACT_MOVE ||
+  if (priv->sample.contact == CONTACT_DOWN ||
       priv->sample.contact == CONTACT_MOVE)
     {
       /* Yes... is the worker thread available?   If not, then apparently
@@ -1127,7 +1127,7 @@ void stmpe811_tscworker(FAR struct stmpe811_dev_s *priv, uint8_t intsta)
    */
 
 ignored:
-  if (priv->sample.contact == CONTACT_MOVE ||
+  if (priv->sample.contact == CONTACT_DOWN ||
       priv->sample.contact == CONTACT_MOVE)
     {
       (void)wd_start(priv->wdog, STMPE811_PENUP_TICKS, stmpe811_timeout,
diff --git a/nuttx/drivers/lcd/st7567.c b/nuttx/drivers/lcd/st7567.c
index f08897710..cc95c603b 100644
--- a/nuttx/drivers/lcd/st7567.c
+++ b/nuttx/drivers/lcd/st7567.c
@@ -455,12 +455,11 @@ static int st7567_putrun(fb_coord_t row, fb_coord_t col, FAR const uint8_t *buff
   FAR struct st7567_dev_s *priv = &g_st7567dev;
   FAR uint8_t *fbptr;
   FAR uint8_t *ptr;
-  uint8_t devcol;
   uint8_t fbmask;
   uint8_t page;
   uint8_t usrmask;
   uint8_t i;
-  int     pixlen;
+  int pixlen;
 
   gvdbg("row: %d col: %d npixels: %d\n", row, col, npixels);
   DEBUGASSERT(buffer);
diff --git a/nuttx/drivers/mtd/mtd_config.c b/nuttx/drivers/mtd/mtd_config.c
index 4fa7b15d5..8f95830d8 100644
--- a/nuttx/drivers/mtd/mtd_config.c
+++ b/nuttx/drivers/mtd/mtd_config.c
@@ -905,7 +905,7 @@ static int  mtdconfig_open(FAR struct file *filep)
 {
   FAR struct inode *inode = filep->f_inode;
   FAR struct mtdconfig_struct_s *dev = inode->i_private;
-  int        ret = OK;
+  int ret;
 
   /* Get exclusive access to the device */
 
diff --git a/nuttx/drivers/net/dm90x0.c b/nuttx/drivers/net/dm90x0.c
index 2f5b26abb..75256c108 100644
--- a/nuttx/drivers/net/dm90x0.c
+++ b/nuttx/drivers/net/dm90x0.c
@@ -908,7 +908,7 @@ static void dm9x_receive(struct dm9x_driver_s *dm9x)
       mdrah = getreg(DM9X_MDRAH);
       mdral = getreg(DM9X_MDRAL);
 
-      getreg(DM9X_MRCMDX);       /* Dummy read */
+      getreg(DM9X_MRCMDX);         /* Dummy read */
       rxbyte = (uint8_t)DM9X_DATA; /* Get the most up-to-date data */
 
       /* Packet ready for receive check */
diff --git a/nuttx/drivers/net/e1000.c b/nuttx/drivers/net/e1000.c
index 3ae5aa0ba..dda9692b7 100644
--- a/nuttx/drivers/net/e1000.c
+++ b/nuttx/drivers/net/e1000.c
@@ -87,45 +87,50 @@
  * Private Types
  ****************************************************************************/
 
-struct tx_ring {
-    struct tx_desc *desc;
-    char *buf;
-    int tail;      // where to write desc
+struct tx_ring
+{
+  struct tx_desc *desc;
+  char *buf;
+  int tail;      /* where to write desc */
 };
 
-struct rx_ring {
-    struct rx_desc *desc;
-    char *buf;
-    int head;      // where to read
-    int tail;      // where to release free desc
-    int free;      // number of freed desc
+struct rx_ring
+{
+  struct rx_desc *desc;
+  char *buf;
+  int head;      /* where to read */
+  int tail;      /* where to release free desc */
+  int free;      /* number of freed desc */
 };
 
-struct e1000_dev {
-    uint32_t phy_mem_base;
-    uint32_t io_mem_base;
-    uint32_t mem_size;
-    int pci_dev_id;
-	uint16_t pci_addr;
-    unsigned char src_mac[6];
-    unsigned char dst_mac[6];
-    struct irq_action int_desc;
-    struct tx_ring tx_ring;
-    struct rx_ring rx_ring;
-    struct e1000_dev *next;
-
-    // NuttX net data
-    bool bifup;               /* true:ifup false:ifdown */
-    WDOG_ID txpoll;           /* TX poll timer */
-    WDOG_ID txtimeout;        /* TX timeout timer */
-
-    /* This holds the information visible to uIP/NuttX */
-
-    struct uip_driver_s uip_dev;  /* Interface understood by uIP */
+struct e1000_dev
+{
+  uint32_t phy_mem_base;
+  uint32_t io_mem_base;
+  uint32_t mem_size;
+  int pci_dev_id;
+  uint16_t pci_addr;
+  unsigned char src_mac[6];
+  unsigned char dst_mac[6];
+  struct irq_action int_desc;
+  struct tx_ring tx_ring;
+  struct rx_ring rx_ring;
+  struct e1000_dev *next;
+
+  /* NuttX net data */
+
+  bool bifup;               /* true:ifup false:ifdown */
+  WDOG_ID txpoll;           /* TX poll timer */
+  WDOG_ID txtimeout;        /* TX timeout timer */
+
+  /* This holds the information visible to uIP/NuttX */
+
+  struct uip_driver_s uip_dev;  /* Interface understood by uIP */
 };
 
-struct e1000_dev_head {
-    struct e1000_dev *next;
+struct e1000_dev_head
+{
+  struct e1000_dev *next;
 };
 
 /****************************************************************************
@@ -165,195 +170,224 @@ static int e1000_rmmac(struct uip_driver_s *dev, const uint8_t *mac);
 /****************************************************************************
  * Private Functions
  ****************************************************************************/
- 
+
 static inline void e1000_outl(struct e1000_dev *dev, int reg, uint32_t val)
 {
-    writel(dev->io_mem_base+reg, val);
+  writel(dev->io_mem_base+reg, val);
 }
 
 static inline uint32_t e1000_inl(struct e1000_dev *dev, int reg)
 {
-    return readl(dev->io_mem_base+reg);
+  return readl(dev->io_mem_base+reg);
 }
 
 /****************************** e1000 driver ********************************/
 
 void e1000_reset(struct e1000_dev *dev)
 {
-    uint32_t dev_control;
-
-    // Reset the network controller hardware
-    dev_control = 0;
-    dev_control |= (1<<0);   // FD-bit (Full Duplex)
-    dev_control |= (0<<2);   // GIOMD-bit (GIO Master Disable)
-    dev_control |= (1<<3);   // LRST-bit (Link Reset)
-    dev_control |= (1<<6);   // SLU-bit (Set Link Up)	
-    dev_control |= (2<<8);   // SPEED=2 (1000Mbps)
-    dev_control |= (0<<11);  // FRCSPD-bit (Force Speed)
-    dev_control |= (0<<12);  // FRCDPLX-bit (Force Duplex)
-    dev_control |= (0<<20);  // ADVD3WUC-bit (Advertise D3 Wake Up Cap)
-    dev_control |= (1<<26);  // RST-bit (Device Reset)
-    dev_control |= (1<<27);  // RFCE-bit (Receive Flow Control Enable)
-    dev_control |= (1<<28);  // TFCE-bit (Transmit Flow Control Enable) 
-    dev_control |= (0<<30);  // VME-bit (VLAN Mode Enable) 
-    dev_control |= (0<<31);  // PHY_RST-bit (PHY Reset)
-
-    e1000_outl(dev, E1000_IMC, 0xFFFFFFFF);
-    e1000_outl(dev, E1000_STATUS, 0x00000000);
-    e1000_outl(dev, E1000_CTRL, dev_control);
-    dev_control &= ~(1<<26);  // clear RST-bit (Device Reset)
-    e1000_outl(dev, E1000_CTRL, dev_control);	
-    up_mdelay(10);
-    e1000_outl(dev, E1000_CTRL_EXT, 0x001401C0);
-    e1000_outl(dev, E1000_IMC, 0xFFFFFFFF);
+  uint32_t dev_control;
+
+  /* Reset the network controller hardware */
+
+  dev_control = 0;
+  dev_control |= (1<<0);   /* FD-bit (Full Duplex) */
+  dev_control |= (0<<2);   /* GIOMD-bit (GIO Master Disable) */
+  dev_control |= (1<<3);   /* LRST-bit (Link Reset) */
+  dev_control |= (1<<6);   /* SLU-bit (Set Link Up) */
+  dev_control |= (2<<8);   /* SPEED=2 (1000Mbps) */
+  dev_control |= (0<<11);  /* FRCSPD-bit (Force Speed) */
+  dev_control |= (0<<12);  /* FRCDPLX-bit (Force Duplex) */
+  dev_control |= (0<<20);  /* ADVD3WUC-bit (Advertise D3 Wake Up Cap) */
+  dev_control |= (1<<26);  /* RST-bit (Device Reset) */
+  dev_control |= (1<<27);  /* RFCE-bit (Receive Flow Control Enable) */
+  dev_control |= (1<<28);  /* TFCE-bit (Transmit Flow Control Enable) */
+  dev_control |= (0<<30);  /* VME-bit (VLAN Mode Enable) */
+  dev_control |= (0<<31);  /* PHY_RST-bit (PHY Reset) */
+
+  e1000_outl(dev, E1000_IMC, 0xFFFFFFFF);
+  e1000_outl(dev, E1000_STATUS, 0x00000000);
+  e1000_outl(dev, E1000_CTRL, dev_control);
+  dev_control &= ~(1<<26);  /* clear RST-bit (Device Reset) */
+  e1000_outl(dev, E1000_CTRL, dev_control);
+  up_mdelay(10);
+  e1000_outl(dev, E1000_CTRL_EXT, 0x001401C0);
+  e1000_outl(dev, E1000_IMC, 0xFFFFFFFF);
 }
 
 void e1000_turn_on(struct e1000_dev *dev)
 {
-    int	tx_control, rx_control;
-    uint32_t ims = 0;
-
-    // turn on the controller's receive engine
-    rx_control = e1000_inl(dev, E1000_RCTL);
-    rx_control |= (1<<1);
-    e1000_outl(dev, E1000_RCTL, rx_control);	
-
-    // turn on the controller's transmit engine
-    tx_control = e1000_inl(dev, E1000_TCTL);
-    tx_control |= (1<<1);
-    e1000_outl(dev, E1000_TCTL, tx_control);	
-
-    // enable the controller's interrupts
-    e1000_outl(dev, E1000_ICR, 0xFFFFFFFF);
-    e1000_outl(dev, E1000_IMC, 0xFFFFFFFF);
-
-    ims |= 1<<0;      // TXDW
-    ims |= 1<<1;      // TXQE
-    ims |= 1<<2;      // LSC
-    ims |= 1<<4;      // RXDMT0 
-    ims |= 1<<7;      // RXT0 
-    e1000_outl(dev, E1000_IMS, ims);
+  int tx_control;
+  int rx_control;
+  uint32_t ims = 0;
+
+  /* turn on the controller's receive engine */
+
+  rx_control = e1000_inl(dev, E1000_RCTL);
+  rx_control |= (1<<1);
+  e1000_outl(dev, E1000_RCTL, rx_control);
+
+  /* turn on the controller's transmit engine */
+
+  tx_control = e1000_inl(dev, E1000_TCTL);
+  tx_control |= (1<<1);
+  e1000_outl(dev, E1000_TCTL, tx_control);
+
+  /* enable the controller's interrupts */
+
+  e1000_outl(dev, E1000_ICR, 0xFFFFFFFF);
+  e1000_outl(dev, E1000_IMC, 0xFFFFFFFF);
+
+  ims |= 1<<0;      /* TXDW */
+  ims |= 1<<1;      /* TXQE */
+  ims |= 1<<2;      /* LSC */
+  ims |= 1<<4;      /* RXDMT0 */
+  ims |= 1<<7;      /* RXT0 */
+  e1000_outl(dev, E1000_IMS, ims);
 }
 
 void e1000_turn_off(struct e1000_dev *dev)
 {
-    int	tx_control, rx_control;
+  int tx_control;
+  int rx_control;
 
-    // turn off the controller's receive engine
-    rx_control = e1000_inl(dev, E1000_RCTL);
-    rx_control &= ~(1<<1);
-    e1000_outl(dev, E1000_RCTL, rx_control);	
+  /* turn off the controller's receive engine */
 
-    // turn off the controller's transmit engine
-    tx_control = e1000_inl(dev, E1000_TCTL);
-    tx_control &= ~(1<<1);
-    e1000_outl(dev, E1000_TCTL, tx_control);	
+  rx_control = e1000_inl(dev, E1000_RCTL);
+  rx_control &= ~(1<<1);
+  e1000_outl(dev, E1000_RCTL, rx_control);
 
-    // turn off the controller's interrupts
-    e1000_outl(dev, E1000_IMC, 0xFFFFFFFF);
+  /* turn off the controller's transmit engine */
+
+  tx_control = e1000_inl(dev, E1000_TCTL);
+  tx_control &= ~(1<<1);
+  e1000_outl(dev, E1000_TCTL, tx_control);
+
+  /* turn off the controller's interrupts */
+
+  e1000_outl(dev, E1000_IMC, 0xFFFFFFFF);
 }
 
 void e1000_init(struct e1000_dev *dev)
 {
-    uint32_t rxd_phys, txd_phys, kmem_phys;
-    uint32_t rx_control, tx_control;
-    uint32_t pba;
-    int i;
-
-    e1000_reset(dev);
-
-    // configure the controller's 'receive' engine
-    rx_control = 0;
-    rx_control |= (0<<1);	  // EN-bit (Enable)
-    rx_control |= (0<<2);	  // SPB-bit (Store Bad Packets) 	
-    rx_control |= (0<<3);	  // UPE-bit (Unicast Promiscuous Mode)
-    rx_control |= (1<<4);	  // MPE-bit (Multicast Promiscuous Mode)
-    rx_control |= (0<<5);	  // LPE-bit (Long Packet Enable)
-    rx_control |= (0<<6);	  // LBM=0 (Loop-Back Mode)
-    rx_control |= (0<<8);	  // RDMTS=0 (Rx Descriptor Min Threshold Size)
-    rx_control |= (0<<10);  // DTYPE=0 (Descriptor Type)
-    rx_control |= (0<<12);  // MO=0 (Multicast Offset)
-    rx_control |= (1<<15);  // BAM-bit (Broadcast Address Mode)
-    rx_control |= (0<<16);  // BSIZE=0 (Buffer Size = 2048) 	
-    rx_control |= (0<<18);  // VLE-bit (VLAN filter Enable)
-    rx_control |= (0<<19);  // CFIEN-bit (Canonical Form Indicator Enable)	
-    rx_control |= (0<<20);  // CFI-bit (Canonical Form Indicator)
-    rx_control |= (1<<22);  // DPF-bit (Discard Pause Frames)	
-    rx_control |= (0<<23);  // PMCF-bit (Pass MAC Control Frames)
-    rx_control |= (0<<25);  // BSEX=0 (Buffer Size EXtension)
-    rx_control |= (1<<26);  // SECRC-bit (Strip Ethernet CRC)
-    rx_control |= (0<<27);  // FLEXBUF=0 (Flexible Buffer size)	
-    e1000_outl(dev, E1000_RCTL, rx_control);
-
-    // configure the controller's 'transmit' engine
-    tx_control = 0;
-    tx_control |= (0<<1);	   // EN-bit (Enable)
-    tx_control |= (1<<3);	   // PSP-bit (Pad Short Packets)
-    tx_control |= (15<<4);   // CT=15 (Collision Threshold)
-    tx_control |= (63<<12);  // COLD=63 (Collision Distance)
-    tx_control |= (0<<22);   // SWXOFF-bit (Software XOFF)
-    tx_control |= (1<<24);   // RTLC-bit (Re-Transmit on Late Collision)
-    tx_control |= (0<<25);   // UNORTX-bit (Underrun No Re-Transmit)
-    tx_control |= (0<<26);   // TXCSCMT=0 (TxDesc Mininum Threshold)
-    tx_control |= (0<<28);   // MULR-bit (Multiple Request Support)
-    e1000_outl(dev, E1000_TCTL, tx_control);
-
-    // hardware flow control
-    pba = e1000_inl(dev, E1000_PBA);
-    // get receive FIFO size
-    pba = (pba & 0x000000ff)<<10;
-    e1000_outl(dev, E1000_FCAL, 0x00C28001);
-    e1000_outl(dev, E1000_FCAH, 0x00000100);
-    e1000_outl(dev, E1000_FCT, 0x00008808);
-    e1000_outl(dev, E1000_FCTTV, 0x00000680);
-    e1000_outl(dev, E1000_FCRTL, (pba*8/10)|0x80000000);
-    e1000_outl(dev, E1000_FCRTH, pba*9/10);
-
-    // setup tx rings
-    txd_phys = PADDR((uintptr_t)dev->tx_ring.desc);
-    kmem_phys = PADDR((uintptr_t)dev->tx_ring.buf);
-    for (i=0; i<CONFIG_E1000_N_TX_DESC; i++,kmem_phys+=CONFIG_E1000_BUFF_SIZE) {
-		dev->tx_ring.desc[i].base_address = kmem_phys;
-		dev->tx_ring.desc[i].packet_length = 0;
-		dev->tx_ring.desc[i].cksum_offset = 0;
-		dev->tx_ring.desc[i].cksum_origin = 0;
-		dev->tx_ring.desc[i].desc_status = 1;
-		dev->tx_ring.desc[i].desc_command = (1<<0)|(1<<1)|(1<<3);
-		dev->tx_ring.desc[i].special_info = 0;
+  uint32_t rxd_phy;
+  uint32_t txd_phys;
+  uint32_t kmem_phys;
+  uint32_t rx_control;
+  uint32_t tx_control;
+  uint32_t pba;
+  int i;
+
+  e1000_reset(dev);
+
+  /* configure the controller's 'receive' engine */
+
+  rx_control = 0;
+  rx_control |= (0<<1);   /* EN-bit (Enable) */
+  rx_control |= (0<<2);   /* SPB-bit (Store Bad Packets) */
+  rx_control |= (0<<3);   /* UPE-bit (Unicast Promiscuous Mode) */
+  rx_control |= (1<<4);   /* MPE-bit (Multicast Promiscuous Mode) */
+  rx_control |= (0<<5);   /* LPE-bit (Long Packet Enable) */
+  rx_control |= (0<<6);   /* LBM=0 (Loop-Back Mode) */
+  rx_control |= (0<<8);   /* RDMTS=0 (Rx Descriptor Min Threshold Size) */
+  rx_control |= (0<<10);  /* DTYPE=0 (Descriptor Type) */
+  rx_control |= (0<<12);  /* MO=0 (Multicast Offset) */
+  rx_control |= (1<<15);  /* BAM-bit (Broadcast Address Mode) */
+  rx_control |= (0<<16);  /* BSIZE=0 (Buffer Size = 2048) */
+  rx_control |= (0<<18);  /* VLE-bit (VLAN filter Enable) */
+  rx_control |= (0<<19);  /* CFIEN-bit (Canonical Form Indicator Enable) */
+  rx_control |= (0<<20);  /* CFI-bit (Canonical Form Indicator) */
+  rx_control |= (1<<22);  /* DPF-bit (Discard Pause Frames) */
+  rx_control |= (0<<23);  /* PMCF-bit (Pass MAC Control Frames) */
+  rx_control |= (0<<25);  /* BSEX=0 (Buffer Size EXtension) */
+  rx_control |= (1<<26);  /* SECRC-bit (Strip Ethernet CRC) */
+  rx_control |= (0<<27);  /* FLEXBUF=0 (Flexible Buffer size) */
+  e1000_outl(dev, E1000_RCTL, rx_control);
+
+  /* configure the controller's 'transmit' engine */
+
+  tx_control = 0;
+  tx_control |= (0<<1);    /* EN-bit (Enable) */
+  tx_control |= (1<<3);    /* PSP-bit (Pad Short Packets) */
+  tx_control |= (15<<4);   /* CT=15 (Collision Threshold) */
+  tx_control |= (63<<12);  /* COLD=63 (Collision Distance) */
+  tx_control |= (0<<22);   /* SWXOFF-bit (Software XOFF) */
+  tx_control |= (1<<24);   /* RTLC-bit (Re-Transmit on Late Collision) */
+  tx_control |= (0<<25);   /* UNORTX-bit (Underrun No Re-Transmit) */
+  tx_control |= (0<<26);   /* TXCSCMT=0 (TxDesc Mininum Threshold) */
+  tx_control |= (0<<28);   /* MULR-bit (Multiple Request Support) */
+  e1000_outl(dev, E1000_TCTL, tx_control);
+
+  /* hardware flow control */
+
+  pba = e1000_inl(dev, E1000_PBA);
+
+  /* get receive FIFO size */
+
+  pba = (pba & 0x000000ff)<<10;
+  e1000_outl(dev, E1000_FCAL, 0x00C28001);
+  e1000_outl(dev, E1000_FCAH, 0x00000100);
+  e1000_outl(dev, E1000_FCT, 0x00008808);
+  e1000_outl(dev, E1000_FCTTV, 0x00000680);
+  e1000_outl(dev, E1000_FCRTL, (pba*8/10)|0x80000000);
+  e1000_outl(dev, E1000_FCRTH, pba*9/10);
+
+  /* setup tx rings */
+
+  txd_phys = PADDR((uintptr_t)dev->tx_ring.desc);
+  kmem_phys = PADDR((uintptr_t)dev->tx_ring.buf);
+  for (i=0; i<CONFIG_E1000_N_TX_DESC; i++,kmem_phys+=CONFIG_E1000_BUFF_SIZE)
+    {
+      dev->tx_ring.desc[i].base_address = kmem_phys;
+      dev->tx_ring.desc[i].packet_length = 0;
+      dev->tx_ring.desc[i].cksum_offset = 0;
+      dev->tx_ring.desc[i].cksum_origin = 0;
+      dev->tx_ring.desc[i].desc_status = 1;
+      dev->tx_ring.desc[i].desc_command = (1<<0)|(1<<1)|(1<<3);
+      dev->tx_ring.desc[i].special_info = 0;
     }
-    dev->tx_ring.tail = 0;
-    e1000_outl(dev, E1000_TDT, 0);
-    e1000_outl(dev, E1000_TDH, 0);
-    // tell controller the location, size, and fetch-policy for Tx queue
-    e1000_outl(dev, E1000_TDBAL, txd_phys);
-    e1000_outl(dev, E1000_TDBAH, 0x00000000);
-    e1000_outl(dev, E1000_TDLEN, CONFIG_E1000_N_TX_DESC*16);
-    e1000_outl(dev, E1000_TXDCTL, 0x01010000);
-
-    // setup rx rings
-    rxd_phys = PADDR((uintptr_t)dev->rx_ring.desc);
-    kmem_phys = PADDR((uintptr_t)dev->rx_ring.buf);
-    for (i=0; i<CONFIG_E1000_N_RX_DESC; i++,kmem_phys+=CONFIG_E1000_BUFF_SIZE) {
-		dev->rx_ring.desc[i].base_address = kmem_phys;
-		dev->rx_ring.desc[i].packet_length = 0;
-		dev->rx_ring.desc[i].packet_cksum = 0;
-		dev->rx_ring.desc[i].desc_status = 0;
-		dev->rx_ring.desc[i].desc_errors = 0;
-		dev->rx_ring.desc[i].vlan_tag = 0;
+
+  dev->tx_ring.tail = 0;
+  e1000_outl(dev, E1000_TDT, 0);
+  e1000_outl(dev, E1000_TDH, 0);
+
+  /* tell controller the location, size, and fetch-policy for Tx queue */
+
+  e1000_outl(dev, E1000_TDBAL, txd_phys);
+  e1000_outl(dev, E1000_TDBAH, 0x00000000);
+  e1000_outl(dev, E1000_TDLEN, CONFIG_E1000_N_TX_DESC*16);
+  e1000_outl(dev, E1000_TXDCTL, 0x01010000);
+
+  /* setup rx rings */
+
+  rxd_phys = PADDR((uintptr_t)dev->rx_ring.desc);
+  kmem_phys = PADDR((uintptr_t)dev->rx_ring.buf);
+  for (i=0; i<CONFIG_E1000_N_RX_DESC; i++,kmem_phys+=CONFIG_E1000_BUFF_SIZE)
+    {
+      dev->rx_ring.desc[i].base_address = kmem_phys;
+      dev->rx_ring.desc[i].packet_length = 0;
+      dev->rx_ring.desc[i].packet_cksum = 0;
+      dev->rx_ring.desc[i].desc_status = 0;
+      dev->rx_ring.desc[i].desc_errors = 0;
+      dev->rx_ring.desc[i].vlan_tag = 0;
     }
-    dev->rx_ring.head = 0;
-    dev->rx_ring.tail = CONFIG_E1000_N_RX_DESC-1;
-    dev->rx_ring.free = 0;
-    // give the controller ownership of all receive descriptors
-    e1000_outl(dev, E1000_RDH, 0);
-    e1000_outl(dev, E1000_RDT, CONFIG_E1000_N_RX_DESC-1);
-    // tell controller the location, size, and fetch-policy for RX queue
-    e1000_outl(dev, E1000_RDBAL, rxd_phys);
-    e1000_outl(dev, E1000_RDBAH, 0x00000000);
-    e1000_outl(dev, E1000_RDLEN, CONFIG_E1000_N_RX_DESC*16);
-    e1000_outl(dev, E1000_RXDCTL, 0x01010000);
-
-    e1000_turn_on(dev);
+
+  dev->rx_ring.head = 0;
+  dev->rx_ring.tail = CONFIG_E1000_N_RX_DESC-1;
+  dev->rx_ring.free = 0;
+
+  /* give the controller ownership of all receive descriptors */
+
+  e1000_outl(dev, E1000_RDH, 0);
+  e1000_outl(dev, E1000_RDT, CONFIG_E1000_N_RX_DESC-1);
+
+  /* tell controller the location, size, and fetch-policy for RX queue */
+
+  e1000_outl(dev, E1000_RDBAL, rxd_phys);
+  e1000_outl(dev, E1000_RDBAH, 0x00000000);
+  e1000_outl(dev, E1000_RDLEN, CONFIG_E1000_N_RX_DESC*16);
+  e1000_outl(dev, E1000_RXDCTL, 0x01010000);
+
+  e1000_turn_on(dev);
 }
 
 /****************************************************************************
@@ -378,39 +412,44 @@ void e1000_init(struct e1000_dev *dev)
 
 static int e1000_transmit(struct e1000_dev *e1000)
 {
-    int tail = e1000->tx_ring.tail;
-    unsigned char *cp = (unsigned char *)
-		(e1000->tx_ring.buf + tail * CONFIG_E1000_BUFF_SIZE);
-    int count = e1000->uip_dev.d_len;
+  int tail = e1000->tx_ring.tail;
+  unsigned char *cp = (unsigned char *)
+      (e1000->tx_ring.buf + tail * CONFIG_E1000_BUFF_SIZE);
+  int count = e1000->uip_dev.d_len;
+
+  /* Verify that the hardware is ready to send another packet.  If we get
+   * here, then we are committed to sending a packet; Higher level logic
+   * must have assured that there is not transmission in progress.
+   */
+
+  if (!e1000->tx_ring.desc[tail].desc_status)
+    {
+      return -1;
+    }
+
+  /* Increment statistics */
 
-    /* Verify that the hardware is ready to send another packet.  If we get
-     * here, then we are committed to sending a packet; Higher level logic
-     * must have assured that there is not transmission in progress.
-     */
+  /* Send the packet: address=skel->sk_dev.d_buf, length=skel->sk_dev.d_len */
 
-    if (!e1000->tx_ring.desc[tail].desc_status)
-		return -1;
+  memcpy(cp, e1000->uip_dev.d_buf, e1000->uip_dev.d_len);
 
-    /* Increment statistics */
+  /* prepare the transmit-descriptor */
 
-    /* Send the packet: address=skel->sk_dev.d_buf, length=skel->sk_dev.d_len */
-    memcpy(cp, e1000->uip_dev.d_buf, e1000->uip_dev.d_len);
+  e1000->tx_ring.desc[tail].packet_length = count<60 ? 60:count;
+  e1000->tx_ring.desc[tail].desc_status = 0;
 
-    // prepare the transmit-descriptor
-    e1000->tx_ring.desc[tail].packet_length = count<60 ? 60:count;
-    e1000->tx_ring.desc[tail].desc_status = 0;
+  /* give ownership of this descriptor to the network controller */
 
-    // give ownership of this descriptor to the network controller
-    tail = (tail + 1) % CONFIG_E1000_N_TX_DESC;
-    e1000->tx_ring.tail = tail;
-    e1000_outl(e1000, E1000_TDT, tail);
+  tail = (tail + 1) % CONFIG_E1000_N_TX_DESC;
+  e1000->tx_ring.tail = tail;
+  e1000_outl(e1000, E1000_TDT, tail);
 
-    /* Enable Tx interrupts */
+  /* Enable Tx interrupts */
 
-    /* Setup the TX timeout watchdog (perhaps restarting the timer) */
+  /* Setup the TX timeout watchdog (perhaps restarting the timer) */
 
-    wd_start(e1000->txtimeout, E1000_TXTIMEOUT, e1000_txtimeout, 1, (uint32_t)e1000);
-    return OK;
+  wd_start(e1000->txtimeout, E1000_TXTIMEOUT, e1000_txtimeout, 1, (uint32_t)e1000);
+  return OK;
 }
 
 /****************************************************************************
@@ -439,29 +478,33 @@ static int e1000_transmit(struct e1000_dev *e1000)
 
 static int e1000_uiptxpoll(struct uip_driver_s *dev)
 {
-    struct e1000_dev *e1000 = (struct e1000_dev *)dev->d_private;
-    int tail = e1000->tx_ring.tail;
-
-    /* If the polling resulted in data that should be sent out on the network,
-     * the field d_len is set to a value > 0.
-     */
-
-    if (e1000->uip_dev.d_len > 0) {
-		uip_arp_out(&e1000->uip_dev);
-		e1000_transmit(e1000);
-
-		/* Check if there is room in the device to hold another packet. If not,
-		 * return a non-zero value to terminate the poll.
-		 */
-		if (!e1000->tx_ring.desc[tail].desc_status)
-			return -1;
+  struct e1000_dev *e1000 = (struct e1000_dev *)dev->d_private;
+  int tail = e1000->tx_ring.tail;
+
+  /* If the polling resulted in data that should be sent out on the network,
+   * the field d_len is set to a value > 0.
+   */
+
+  if (e1000->uip_dev.d_len > 0)
+    {
+      uip_arp_out(&e1000->uip_dev);
+      e1000_transmit(e1000);
+
+      /* Check if there is room in the device to hold another packet. If not,
+       * return a non-zero value to terminate the poll.
+       */
+
+      if (!e1000->tx_ring.desc[tail].desc_status)
+        {
+          return -1;
+        }
     }
 
-    /* If zero is returned, the polling will continue until all connections have
-     * been examined.
-     */
+  /* If zero is returned, the polling will continue until all connections have
+   * been examined.
+   */
 
-    return 0;
+  return 0;
 }
 
 /****************************************************************************
@@ -483,77 +526,87 @@ static int e1000_uiptxpoll(struct uip_driver_s *dev)
 
 static void e1000_receive(struct e1000_dev *e1000)
 {
-    int head = e1000->rx_ring.head;
-    unsigned char *cp = (unsigned char *)
-		(e1000->rx_ring.buf + head * CONFIG_E1000_BUFF_SIZE);
-    int cnt;
-
-    while (e1000->rx_ring.desc[head].desc_status) {
-
-		/* Check for errors and update statistics */
-	
-		// Here we do not handle packets that exceed packet-buffer size
-		if ((e1000->rx_ring.desc[head].desc_status & 3) == 1) {
-			cprintf("NIC READ: Oversized packet\n");
-			goto next;
-		}
-	
-		/* Check if the packet is a valid size for the uIP buffer configuration */
-	
-		// get the number of actual data-bytes in this packet
-		cnt = e1000->rx_ring.desc[head].packet_length;
-	
-		if (cnt > CONFIG_NET_BUFSIZE || cnt < 14) {
-			cprintf("NIC READ: invalid package size\n");
-			goto next;
-		}
-    
-		/* Copy the data data from the hardware to e1000->uip_dev.d_buf.  Set
-		 * amount of data in e1000->uip_dev.d_len
-		 */
-    
-		// now we try to copy these data-bytes to the UIP buffer
-		memcpy(e1000->uip_dev.d_buf, cp, cnt);
-		e1000->uip_dev.d_len = cnt;
-
-		/* We only accept IP packets of the configured type and ARP packets */
+  int head = e1000->rx_ring.head;
+  unsigned char *cp = (unsigned char *)
+      (e1000->rx_ring.buf + head * CONFIG_E1000_BUFF_SIZE);
+  int cnt;
+
+  while (e1000->rx_ring.desc[head].desc_status)
+    {
+      /* Check for errors and update statistics */
+
+      /* Here we do not handle packets that exceed packet-buffer size */
+
+      if ((e1000->rx_ring.desc[head].desc_status & 3) == 1)
+        {
+          cprintf("NIC READ: Oversized packet\n");
+          goto next;
+        }
+
+      /* Check if the packet is a valid size for the uIP buffer configuration */
+
+      /* get the number of actual data-bytes in this packet */
+
+      cnt = e1000->rx_ring.desc[head].packet_length;
+
+      if (cnt > CONFIG_NET_BUFSIZE || cnt < 14)
+        {
+          cprintf("NIC READ: invalid package size\n");
+          goto next;
+        }
+
+      /* Copy the data data from the hardware to e1000->uip_dev.d_buf.  Set
+       * amount of data in e1000->uip_dev.d_len
+       */
+
+      /* now we try to copy these data-bytes to the UIP buffer */
+
+      memcpy(e1000->uip_dev.d_buf, cp, cnt);
+      e1000->uip_dev.d_len = cnt;
+
+      /* We only accept IP packets of the configured type and ARP packets */
 
 #ifdef CONFIG_NET_IPv6
-		if (BUF->type == HTONS(UIP_ETHTYPE_IP6))
+      if (BUF->type == HTONS(UIP_ETHTYPE_IP6))
 #else
-			if (BUF->type == HTONS(UIP_ETHTYPE_IP))
+        {
+          if (BUF->type == HTONS(UIP_ETHTYPE_IP))
 #endif
-			{
-				uip_arp_ipin(&e1000->uip_dev);
-				uip_input(&e1000->uip_dev);
-
-				/* If the above function invocation resulted in data that should be
-				 * sent out on the network, the field  d_len will set to a value > 0.
-				 */
-
-				if (e1000->uip_dev.d_len > 0) {
-					uip_arp_out(&e1000->uip_dev);
-					e1000_transmit(e1000);
-				}
-			}
-			else if (BUF->type == htons(UIP_ETHTYPE_ARP)) {
-				uip_arp_arpin(&e1000->uip_dev);
-
-				/* If the above function invocation resulted in data that should be
-				 * sent out on the network, the field  d_len will set to a value > 0.
-				 */
-
-				if (e1000->uip_dev.d_len > 0) {
-					e1000_transmit(e1000);
-				}
-			}
-
-    next:
-		e1000->rx_ring.desc[head].desc_status = 0;
-		e1000->rx_ring.head = (head + 1) % CONFIG_E1000_N_RX_DESC;
-		e1000->rx_ring.free++;
-		head = e1000->rx_ring.head;
-		cp = (unsigned char *)(e1000->rx_ring.buf + head * CONFIG_E1000_BUFF_SIZE);
+            {
+              uip_arp_ipin(&e1000->uip_dev);
+              uip_input(&e1000->uip_dev);
+
+              /* If the above function invocation resulted in data that should be
+               * sent out on the network, the field  d_len will set to a value > 0.
+               */
+
+              if (e1000->uip_dev.d_len > 0)
+                {
+                  uip_arp_out(&e1000->uip_dev);
+                  e1000_transmit(e1000);
+                }
+            }
+          else if (BUF->type == htons(UIP_ETHTYPE_ARP))
+            {
+              uip_arp_arpin(&e1000->uip_dev);
+
+              /* If the above function invocation resulted in data that should be
+               * sent out on the network, the field  d_len will set to a value > 0.
+               */
+
+              if (e1000->uip_dev.d_len > 0)
+                {
+                  e1000_transmit(e1000);
+                }
+            }
+        }
+
+next:
+      e1000->rx_ring.desc[head].desc_status = 0;
+      e1000->rx_ring.head = (head + 1) % CONFIG_E1000_N_RX_DESC;
+      e1000->rx_ring.free++;
+      head = e1000->rx_ring.head;
+      cp = (unsigned char *)(e1000->rx_ring.buf + head * CONFIG_E1000_BUFF_SIZE);
     }
 }
 
@@ -578,16 +631,17 @@ static void e1000_receive(struct e1000_dev *e1000)
 
 static void e1000_txtimeout(int argc, uint32_t arg, ...)
 {
-    struct e1000_dev *e1000 = (struct e1000_dev *)arg;
+  struct e1000_dev *e1000 = (struct e1000_dev *)arg;
+
+  /* Increment statistics and dump debug info */
 
-    /* Increment statistics and dump debug info */
+  /* Then reset the hardware */
 
-    /* Then reset the hardware */
-    e1000_init(e1000);
+  e1000_init(e1000);
 
-    /* Then poll uIP for new XMIT data */
+  /* Then poll uIP for new XMIT data */
 
-    (void)uip_poll(&e1000->uip_dev, e1000_uiptxpoll);
+  (void)uip_poll(&e1000->uip_dev, e1000_uiptxpoll);
 }
 
 /****************************************************************************
@@ -610,25 +664,28 @@ static void e1000_txtimeout(int argc, uint32_t arg, ...)
 
 static void e1000_polltimer(int argc, uint32_t arg, ...)
 {
-    struct e1000_dev *e1000 = (struct e1000_dev *)arg;
-    int tail = e1000->tx_ring.tail;
+  struct e1000_dev *e1000 = (struct e1000_dev *)arg;
+  int tail = e1000->tx_ring.tail;
 
-    /* Check if there is room in the send another TX packet.  We cannot perform
-     * the TX poll if he are unable to accept another packet for transmission.
-     */
-    if (!e1000->tx_ring.desc[tail].desc_status)
-		return;
+  /* Check if there is room in the send another TX packet.  We cannot perform
+   * the TX poll if he are unable to accept another packet for transmission.
+   */
 
-    /* If so, update TCP timing states and poll uIP for new XMIT data. Hmmm..
-     * might be bug here.  Does this mean if there is a transmit in progress,
-     * we will missing TCP time state updates?
-     */
+  if (!e1000->tx_ring.desc[tail].desc_status)
+    {
+      return;
+    }
+
+  /* If so, update TCP timing states and poll uIP for new XMIT data. Hmmm..
+   * might be bug here.  Does this mean if there is a transmit in progress,
+   * we will missing TCP time state updates?
+   */
 
-    (void)uip_timer(&e1000->uip_dev, e1000_uiptxpoll, E1000_POLLHSEC);
+  (void)uip_timer(&e1000->uip_dev, e1000_uiptxpoll, E1000_POLLHSEC);
 
-    /* Setup the watchdog poll timer again */
+  /* Setup the watchdog poll timer again */
 
-    (void)wd_start(e1000->txpoll, E1000_WDDELAY, e1000_polltimer, 1, arg);
+  (void)wd_start(e1000->txpoll, E1000_WDDELAY, e1000_polltimer, 1, arg);
 }
 
 /****************************************************************************
@@ -636,7 +693,7 @@ static void e1000_polltimer(int argc, uint32_t arg, ...)
  *
  * Description:
  *   NuttX Callback: Bring up the Ethernet interface when an IP address is
- *   provided 
+ *   provided
  *
  * Parameters:
  *   dev  - Reference to the NuttX driver state structure
@@ -650,25 +707,30 @@ static void e1000_polltimer(int argc, uint32_t arg, ...)
 
 static int e1000_ifup(struct uip_driver_s *dev)
 {
-    struct e1000_dev *e1000 = (struct e1000_dev *)dev->d_private;
+  struct e1000_dev *e1000 = (struct e1000_dev *)dev->d_private;
+
+  ndbg("Bringing up: %d.%d.%d.%d\n",
+       dev->d_ipaddr & 0xff, (dev->d_ipaddr >> 8) & 0xff,
+       (dev->d_ipaddr >> 16) & 0xff, dev->d_ipaddr >> 24 );
 
-    ndbg("Bringing up: %d.%d.%d.%d\n",
-		 dev->d_ipaddr & 0xff, (dev->d_ipaddr >> 8) & 0xff,
-		 (dev->d_ipaddr >> 16) & 0xff, dev->d_ipaddr >> 24 );
+  /* Initialize PHYs, the Ethernet interface, and setup up Ethernet interrupts */
 
-    /* Initialize PHYs, the Ethernet interface, and setup up Ethernet interrupts */
-    e1000_init(e1000);
+  e1000_init(e1000);
 
-    /* Set and activate a timer process */
+  /* Set and activate a timer process */
 
-    (void)wd_start(e1000->txpoll, E1000_WDDELAY, e1000_polltimer, 1, (uint32_t)e1000);
+  (void)wd_start(e1000->txpoll, E1000_WDDELAY, e1000_polltimer, 1, (uint32_t)e1000);
 
-    if (e1000_inl(e1000, E1000_STATUS) & 2)
-		e1000->bifup = true;
-    else
-		e1000->bifup = false;
+  if (e1000_inl(e1000, E1000_STATUS) & 2)
+    {
+      e1000->bifup = true;
+    }
+  else
+    {
+      e1000->bifup = false;
+    }
 
-    return OK;
+  return OK;
 }
 
 /****************************************************************************
@@ -689,39 +751,40 @@ static int e1000_ifup(struct uip_driver_s *dev)
 
 static int e1000_ifdown(struct uip_driver_s *dev)
 {
-    struct e1000_dev *e1000 = (struct e1000_dev *)dev->d_private;
-    irqstate_t flags;
+  struct e1000_dev *e1000 = (struct e1000_dev *)dev->d_private;
+  irqstate_t flags;
+
+  /* Disable the Ethernet interrupt */
 
-    /* Disable the Ethernet interrupt */
+  flags = irqsave();
 
-    flags = irqsave();
+  e1000_turn_off(e1000);
 
-    e1000_turn_off(e1000);
+  /* Cancel the TX poll timer and TX timeout timers */
 
-    /* Cancel the TX poll timer and TX timeout timers */
+  wd_cancel(e1000->txpoll);
+  wd_cancel(e1000->txtimeout);
 
-    wd_cancel(e1000->txpoll);
-    wd_cancel(e1000->txtimeout);
+  /* Put the EMAC is its reset, non-operational state.  This should be
+   * a known configuration that will guarantee the skel_ifup() always
+   * successfully brings the interface back up.
+   */
 
-    /* Put the EMAC is its reset, non-operational state.  This should be
-     * a known configuration that will guarantee the skel_ifup() always
-     * successfully brings the interface back up.
-     */
-    //e1000_reset(e1000);
+  //e1000_reset(e1000);
 
-    /* Mark the device "down" */
+  /* Mark the device "down" */
 
-    e1000->bifup = false;
-    irqrestore(flags);
+  e1000->bifup = false;
+  irqrestore(flags);
 
-    return OK;
+  return OK;
 }
 
 /****************************************************************************
  * Function: e1000_txavail
  *
  * Description:
- *   Driver callback invoked when new TX data is available.  This is a 
+ *   Driver callback invoked when new TX data is available.  This is a
  *   stimulus perform an out-of-cycle poll and, thereby, reduce the TX
  *   latency.
  *
@@ -738,26 +801,30 @@ static int e1000_ifdown(struct uip_driver_s *dev)
 
 static int e1000_txavail(struct uip_driver_s *dev)
 {
-    struct e1000_dev *e1000 = (struct e1000_dev *)dev->d_private;
-    int tail = e1000->tx_ring.tail;
-    irqstate_t flags;
+  struct e1000_dev *e1000 = (struct e1000_dev *)dev->d_private;
+  int tail = e1000->tx_ring.tail;
+  irqstate_t flags;
 
-    /* Disable interrupts because this function may be called from interrupt
-     * level processing.
-     */
+  /* Disable interrupts because this function may be called from interrupt
+   * level processing.
+   */
 
-    flags = irqsave();
+  flags = irqsave();
 
-    /* Ignore the notification if the interface is not yet up */
+  /* Ignore the notification if the interface is not yet up */
 
-    if (e1000->bifup) {
-		/* Check if there is room in the hardware to hold another outgoing packet. */
-		if (e1000->tx_ring.desc[tail].desc_status)
-			(void)uip_poll(&e1000->uip_dev, e1000_uiptxpoll);
+  if (e1000->bifup)
+    {
+      /* Check if there is room in the hardware to hold another outgoing packet. */
+
+      if (e1000->tx_ring.desc[tail].desc_status)
+        {
+          (void)uip_poll(&e1000->uip_dev, e1000_uiptxpoll);
+        }
     }
 
-    irqrestore(flags);
-    return OK;
+  irqrestore(flags);
+  return OK;
 }
 
 /****************************************************************************
@@ -769,7 +836,7 @@ static int e1000_txavail(struct uip_driver_s *dev)
  *
  * Parameters:
  *   dev  - Reference to the NuttX driver state structure
- *   mac  - The MAC address to be added 
+ *   mac  - The MAC address to be added
  *
  * Returned Value:
  *   None
@@ -781,11 +848,9 @@ static int e1000_txavail(struct uip_driver_s *dev)
 #ifdef CONFIG_NET_IGMP
 static int e1000_addmac(struct uip_driver_s *dev, const uint8_t *mac)
 {
-	struct e1000_dev *e1000 = (struct e1000_dev *)dev->d_private;
-
-	/* Add the MAC address to the hardware multicast routing table */
+  /* Add the MAC address to the hardware multicast routing table */
 
-	return OK;
+  return OK;
 }
 #endif
 
@@ -798,7 +863,7 @@ static int e1000_addmac(struct uip_driver_s *dev, const uint8_t *mac)
  *
  * Parameters:
  *   dev  - Reference to the NuttX driver state structure
- *   mac  - The MAC address to be removed 
+ *   mac  - The MAC address to be removed
  *
  * Returned Value:
  *   None
@@ -810,201 +875,252 @@ static int e1000_addmac(struct uip_driver_s *dev, const uint8_t *mac)
 #ifdef CONFIG_NET_IGMP
 static int e1000_rmmac(struct uip_driver_s *dev, const uint8_t *mac)
 {
-	struct e1000_dev *e1000 = (struct e1000_dev *)dev->d_private;
-
-	/* Add the MAC address to the hardware multicast routing table */
+  /* Add the MAC address to the hardware multicast routing table */
 
-	return OK;
+  return OK;
 }
 #endif
 
 static irqreturn_t e1000_interrupt_handler(int irq, void *dev_id)
 {
-    struct e1000_dev *e1000 = (struct e1000_dev *)dev_id;
-    
-    /* Get and clear interrupt status bits */
-    int intr_cause = e1000_inl(e1000, E1000_ICR);
-    e1000_outl(e1000, E1000_ICR, intr_cause);
-
-    // not for me
-    if (intr_cause == 0) 
-		return IRQ_NONE;
-
-    /* Handle interrupts according to status bit settings */
-
-    // Link status change
-    if (intr_cause & (1<<2)) {
-		if (e1000_inl(e1000, E1000_STATUS) & 2)
-			e1000->bifup = true;
-		else
-			e1000->bifup = false;
+  struct e1000_dev *e1000 = (struct e1000_dev *)dev_id;
+
+  /* Get and clear interrupt status bits */
+
+  int intr_cause = e1000_inl(e1000, E1000_ICR);
+  e1000_outl(e1000, E1000_ICR, intr_cause);
+
+  /* not for me */
+
+  if (intr_cause == 0)
+    {
+      return IRQ_NONE;
+    }
+
+  /* Handle interrupts according to status bit settings */
+
+  /* Link status change */
+
+  if (intr_cause & (1<<2))
+    {
+      if (e1000_inl(e1000, E1000_STATUS) & 2)
+        {
+          e1000->bifup = true;
+        }
+      else
+        {
+          e1000->bifup = false;
+        }
+    }
+
+  /* Check if we received an incoming packet, if so, call skel_receive() */
+
+  /* Rx-descriptor Timer expired */
+
+  if (intr_cause & (1<<7))
+    {
+      e1000_receive(e1000);
+    }
+
+  /* Tx queue empty */
+
+  if (intr_cause & (1<<1))
+    {
+      wd_cancel(e1000->txtimeout);
     }
-    
-    /* Check if we received an incoming packet, if so, call skel_receive() */
-
-    // Rx-descriptor Timer expired
-    if (intr_cause & (1<<7))
-		e1000_receive(e1000);
-
-    // Tx queue empty
-    if (intr_cause & (1<<1))
-		wd_cancel(e1000->txtimeout);
-
-    /* Check is a packet transmission just completed.  If so, call skel_txdone.
-     * This may disable further Tx interrupts if there are no pending
-     * tansmissions.
-     */
-
-    // Tx-descriptor Written back
-    if (intr_cause & (1<<0))
-		uip_poll(&e1000->uip_dev, e1000_uiptxpoll);
-  
-
-    // Rx-Descriptors Low
-    if (intr_cause & (1<<4)) {
-		int tail;
-		tail = e1000->rx_ring.tail + e1000->rx_ring.free;
-		tail %= CONFIG_E1000_N_RX_DESC;
-		e1000->rx_ring.tail = tail;
-		e1000->rx_ring.free = 0;
-		e1000_outl(e1000, E1000_RDT, tail);
+
+  /* Check is a packet transmission just completed.  If so, call skel_txdone.
+   * This may disable further Tx interrupts if there are no pending
+   * tansmissions.
+   */
+
+  /* Tx-descriptor Written back */
+
+  if (intr_cause & (1<<0))
+    {
+      uip_poll(&e1000->uip_dev, e1000_uiptxpoll);
+    }
+
+
+  /* Rx-Descriptors Low */
+
+  if (intr_cause & (1<<4))
+    {
+      int tail;
+
+      tail = e1000->rx_ring.tail + e1000->rx_ring.free;
+      tail %= CONFIG_E1000_N_RX_DESC;
+      e1000->rx_ring.tail = tail;
+      e1000->rx_ring.free = 0;
+      e1000_outl(e1000, E1000_RDT, tail);
     }
 
-    return IRQ_HANDLED;
+  return IRQ_HANDLED;
 }
 
 /******************************* PCI driver *********************************/
 
-static pci_id_t e1000_id_table[] = {
-    {.sep = {INTEL_VENDERID, E1000_82573L}},
-    {.sep = {INTEL_VENDERID, E1000_82540EM}},
-    {.sep = {INTEL_VENDERID, E1000_82574L}},
-    {.sep = {INTEL_VENDERID, E1000_82567LM}},
-    {.sep = {INTEL_VENDERID, E1000_82541PI}},
-    {.sep = {0,0}}	
+static pci_id_t e1000_id_table[] =
+{
+  {.sep = {INTEL_VENDERID, E1000_82573L}},
+  {.sep = {INTEL_VENDERID, E1000_82540EM}},
+  {.sep = {INTEL_VENDERID, E1000_82574L}},
+  {.sep = {INTEL_VENDERID, E1000_82567LM}},
+  {.sep = {INTEL_VENDERID, E1000_82541PI}},
+  {.sep = {0,0}}
 };
 
 static int e1000_probe(uint16_t addr, pci_id_t id)
 {
-    uint32_t mmio_base, mmio_size;
-    uint32_t size;
-    int err;
-    void *kmem, *omem;
-    struct e1000_dev *dev;
-
-    // alloc e1000_dev memory
-    if ((dev = kzalloc(sizeof(struct e1000_dev))) == NULL)
-		return -1;
-
-	// save pci addr
-	dev->pci_addr = addr;
-
-    // enable device
-	if ((err = pci_enable_device(addr, PCI_BUS_MASTER)) < 0)
-		goto error;
-
-    // get e1000 device type
-    dev->pci_dev_id = id.join;
-
-    // remap the controller's i/o-memory into kernel's address-space
-    mmio_base = pci_resource_start(addr, 0);
-    mmio_size = pci_resource_len(addr, 0);
-    err = rgmp_memmap_nocache(mmio_base, mmio_size, mmio_base);
-    if (err) 
-		goto error;
-    dev->phy_mem_base = mmio_base;
-    dev->io_mem_base = mmio_base;
-    dev->mem_size = mmio_size;
-
-    // MAC address
-    memset(dev->dst_mac, 0xFF, 6);
-    memcpy(dev->src_mac, (void *)(dev->io_mem_base+E1000_RA), 6);
-
-    // IRQ setup
-    dev->int_desc.handler = e1000_interrupt_handler;
-    dev->int_desc.dev_id = dev;
-	if ((err = pci_request_irq(addr, &dev->int_desc, 0)) < 0)
-		goto err0;
-
-    // Here we alloc a big block of memory once and make it
-    // aligned to page boundary and multiple of page size. This
-    // is because the memory can be modified by E1000 DMA and
-    // should be mapped no-cache which will hugely reduce memory 
-    // access performance. The page size alloc will restrict
-    // this bad effect only within the memory we alloc here.
-	//
-	// NEED FIX: the memalign may alloc memory continous in
-	// virtual address but dis-continous in physical address
-	// due to RGMP memory setup.
-    size = CONFIG_E1000_N_TX_DESC * sizeof(struct tx_desc) +
-		CONFIG_E1000_N_TX_DESC * CONFIG_E1000_BUFF_SIZE +
-		CONFIG_E1000_N_RX_DESC * sizeof(struct rx_desc) + 
-		CONFIG_E1000_N_RX_DESC * CONFIG_E1000_BUFF_SIZE;
-    size = ROUNDUP(size, PGSIZE);
-    omem = kmem = memalign(PGSIZE, size);
-    if (kmem == NULL) {
-		err = -ENOMEM;
-		goto err1;
+  uint32_t mmio_base, mmio_size;
+  uint32_t size;
+  int err;
+  void *kmem;
+  void *omem;
+  struct e1000_dev *dev;
+
+  /* alloc e1000_dev memory */
+
+  if ((dev = kzalloc(sizeof(struct e1000_dev))) == NULL)
+    {
+      return -1;
     }
-    rgmp_memremap_nocache((uintptr_t)kmem, size);
 
-    // alloc memory for tx ring
-    dev->tx_ring.desc = (struct tx_desc*)kmem;
-    kmem += CONFIG_E1000_N_TX_DESC * sizeof(struct tx_desc);
-    dev->tx_ring.buf = kmem;
-    kmem += CONFIG_E1000_N_TX_DESC * CONFIG_E1000_BUFF_SIZE;
+  /* save pci addr */
 
-    // alloc memory for rx rings
-    dev->rx_ring.desc = (struct rx_desc*)kmem;
-    kmem += CONFIG_E1000_N_RX_DESC * sizeof(struct rx_desc);
-    dev->rx_ring.buf = kmem;
+  dev->pci_addr = addr;
+
+  /* enable device */
+
+  if ((err = pci_enable_device(addr, PCI_BUS_MASTER)) < 0)
+    {
+      goto error;
+    }
 
-    /* Initialize the driver structure */
+  /* get e1000 device type */
 
-    dev->uip_dev.d_ifup    = e1000_ifup;     /* I/F up (new IP address) callback */
-    dev->uip_dev.d_ifdown  = e1000_ifdown;   /* I/F down callback */
-    dev->uip_dev.d_txavail = e1000_txavail;  /* New TX data callback */
+  dev->pci_dev_id = id.join;
+
+  /* remap the controller's i/o-memory into kernel's address-space */
+
+  mmio_base = pci_resource_start(addr, 0);
+  mmio_size = pci_resource_len(addr, 0);
+  err = rgmp_memmap_nocache(mmio_base, mmio_size, mmio_base);
+  if (err)
+    {
+      goto error;
+    }
+
+  dev->phy_mem_base = mmio_base;
+  dev->io_mem_base = mmio_base;
+  dev->mem_size = mmio_size;
+
+  /* MAC address */
+
+  memset(dev->dst_mac, 0xFF, 6);
+  memcpy(dev->src_mac, (void *)(dev->io_mem_base+E1000_RA), 6);
+
+  /* IRQ setup */
+
+  dev->int_desc.handler = e1000_interrupt_handler;
+  dev->int_desc.dev_id = dev;
+  if ((err = pci_request_irq(addr, &dev->int_desc, 0)) < 0)
+    {
+      goto err0;
+    }
+
+  /* Here we alloc a big block of memory once and make it
+   * aligned to page boundary and multiple of page size. This
+   * is because the memory can be modified by E1000 DMA and
+   * should be mapped no-cache which will hugely reduce memory
+   * access performance. The page size alloc will restrict
+   * this bad effect only within the memory we alloc here.
+   *
+   * NEED FIX: the memalign may alloc memory continous in
+   * virtual address but dis-continous in physical address
+   * due to RGMP memory setup.
+   */
+
+  size = CONFIG_E1000_N_TX_DESC * sizeof(struct tx_desc) +
+         CONFIG_E1000_N_TX_DESC * CONFIG_E1000_BUFF_SIZE +
+         CONFIG_E1000_N_RX_DESC * sizeof(struct rx_desc) +
+         CONFIG_E1000_N_RX_DESC * CONFIG_E1000_BUFF_SIZE;
+  size = ROUNDUP(size, PGSIZE);
+  omem = kmem = memalign(PGSIZE, size);
+  if (kmem == NULL)
+    {
+      err = -ENOMEM;
+      goto err1;
+    }
+
+  rgmp_memremap_nocache((uintptr_t)kmem, size);
+
+  /* alloc memory for tx ring */
+
+  dev->tx_ring.desc = (struct tx_desc*)kmem;
+  kmem += CONFIG_E1000_N_TX_DESC * sizeof(struct tx_desc);
+  dev->tx_ring.buf = kmem;
+  kmem += CONFIG_E1000_N_TX_DESC * CONFIG_E1000_BUFF_SIZE;
+
+  /* alloc memory for rx rings */
+
+  dev->rx_ring.desc = (struct rx_desc*)kmem;
+  kmem += CONFIG_E1000_N_RX_DESC * sizeof(struct rx_desc);
+  dev->rx_ring.buf = kmem;
+
+  /* Initialize the driver structure */
+
+  dev->uip_dev.d_ifup    = e1000_ifup;     /* I/F up (new IP address) callback */
+  dev->uip_dev.d_ifdown  = e1000_ifdown;   /* I/F down callback */
+  dev->uip_dev.d_txavail = e1000_txavail;  /* New TX data callback */
 #ifdef CONFIG_NET_IGMP
-    dev->uip_dev.d_addmac  = e1000_addmac;   /* Add multicast MAC address */
-    dev->uip_dev.d_rmmac   = e1000_rmmac;    /* Remove multicast MAC address */
+  dev->uip_dev.d_addmac  = e1000_addmac;   /* Add multicast MAC address */
+  dev->uip_dev.d_rmmac   = e1000_rmmac;    /* Remove multicast MAC address */
 #endif
-    dev->uip_dev.d_private = dev;            /* Used to recover private state from dev */
+  dev->uip_dev.d_private = dev;            /* Used to recover private state from dev */
 
-    /* Create a watchdog for timing polling for and timing of transmisstions */
+  /* Create a watchdog for timing polling for and timing of transmisstions */
 
-    dev->txpoll       = wd_create();         /* Create periodic poll timer */
-    dev->txtimeout    = wd_create();         /* Create TX timeout timer */
+  dev->txpoll       = wd_create();         /* Create periodic poll timer */
+  dev->txtimeout    = wd_create();         /* Create TX timeout timer */
 
-    // Put the interface in the down state.
-    // e1000 reset
-    e1000_reset(dev);
+  /* Put the interface in the down state.
+   * e1000 reset
+   */
 
-    /* Read the MAC address from the hardware */
-    memcpy(dev->uip_dev.d_mac.ether_addr_octet, (void *)(dev->io_mem_base+E1000_RA), 6);
+  e1000_reset(dev);
+
+  /* Read the MAC address from the hardware */
+
+  memcpy(dev->uip_dev.d_mac.ether_addr_octet, (void *)(dev->io_mem_base+E1000_RA), 6);
+
+  /* Register the device with the OS so that socket IOCTLs can be performed */
+
+  err = netdev_register(&dev->uip_dev);
+  if (err)
+    {
+      goto err2;
+    }
 
-    /* Register the device with the OS so that socket IOCTLs can be performed */
-    err = netdev_register(&dev->uip_dev);
-    if (err)
-		goto err2;
+  /* insert into e1000_list */
 
-    // insert into e1000_list
-    dev->next = e1000_list.next;
-    e1000_list.next = dev;
-    cprintf("bring up e1000 device: %04x %08x\n", addr, id.join);
+  dev->next = e1000_list.next;
+  e1000_list.next = dev;
+  cprintf("bring up e1000 device: %04x %08x\n", addr, id.join);
 
-    return 0;
+  return 0;
 
 err2:
-    rgmp_memremap((uintptr_t)omem, size);
-    free(omem);
+  rgmp_memremap((uintptr_t)omem, size);
+  free(omem);
 err1:
-    pci_free_irq(addr);
+  pci_free_irq(addr);
 err0:
-    rgmp_memunmap(mmio_base, mmio_size);
+  rgmp_memunmap(mmio_base, mmio_size);
 error:
-    kfree(dev);
-    cprintf("e1000 device probe fail: %d\n", err);
-    return err;
+  kfree(dev);
+  cprintf("e1000 device probe fail: %d\n", err);
+  return err;
 }
 
 /****************************************************************************
@@ -1013,31 +1129,32 @@ error:
 
 void e1000_mod_init(void)
 {
-    pci_probe_device(e1000_id_table, e1000_probe);
+  pci_probe_device(e1000_id_table, e1000_probe);
 }
 
 void e1000_mod_exit(void)
 {
-    uint32_t size;
-    struct e1000_dev *dev;
-
-    size = CONFIG_E1000_N_TX_DESC * sizeof(struct tx_desc) +
-		CONFIG_E1000_N_TX_DESC * CONFIG_E1000_BUFF_SIZE +
-		CONFIG_E1000_N_RX_DESC * sizeof(struct rx_desc) + 
-		CONFIG_E1000_N_RX_DESC * CONFIG_E1000_BUFF_SIZE;
-    size = ROUNDUP(size, PGSIZE);
-
-    for (dev=e1000_list.next; dev!=NULL; dev=dev->next) {
-		netdev_unregister(&dev->uip_dev);
-		e1000_reset(dev);
-		wd_delete(dev->txpoll);
-		wd_delete(dev->txtimeout);
-		rgmp_memremap((uintptr_t)dev->tx_ring.desc, size);
-		free(dev->tx_ring.desc);
-		pci_free_irq(dev->pci_addr);
-		rgmp_memunmap((uintptr_t)dev->io_mem_base, dev->mem_size);
-		kfree(dev);
+  uint32_t size;
+  struct e1000_dev *dev;
+
+  size = CONFIG_E1000_N_TX_DESC * sizeof(struct tx_desc) +
+         CONFIG_E1000_N_TX_DESC * CONFIG_E1000_BUFF_SIZE +
+         CONFIG_E1000_N_RX_DESC * sizeof(struct rx_desc) +
+        CONFIG_E1000_N_RX_DESC * CONFIG_E1000_BUFF_SIZE;
+  size = ROUNDUP(size, PGSIZE);
+
+  for (dev=e1000_list.next; dev!=NULL; dev=dev->next)
+    {
+      netdev_unregister(&dev->uip_dev);
+      e1000_reset(dev);
+      wd_delete(dev->txpoll);
+      wd_delete(dev->txtimeout);
+      rgmp_memremap((uintptr_t)dev->tx_ring.desc, size);
+      free(dev->tx_ring.desc);
+      pci_free_irq(dev->pci_addr);
+      rgmp_memunmap((uintptr_t)dev->io_mem_base, dev->mem_size);
+      kfree(dev);
     }
 
-    e1000_list.next = NULL;
+  e1000_list.next = NULL;
 }
diff --git a/nuttx/drivers/power/battery.c b/nuttx/drivers/power/battery.c
index 698e5571b..d093ce7d6 100644
--- a/nuttx/drivers/power/battery.c
+++ b/nuttx/drivers/power/battery.c
@@ -152,7 +152,7 @@ static int bat_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
 {
   FAR struct inode *inode = filep->f_inode;
   FAR struct battery_dev_s *dev  = inode->i_private;
-  int ret   = -EINVAL;
+  int ret;
 
   /* Inforce mutually exclusive access to the battery driver */
 
diff --git a/nuttx/drivers/sercomm/console.c b/nuttx/drivers/sercomm/console.c
index 3d038af7c..c066e8fe7 100644
--- a/nuttx/drivers/sercomm/console.c
+++ b/nuttx/drivers/sercomm/console.c
@@ -50,10 +50,12 @@
 #include <nuttx/sercomm/sercomm.h>
 
 /* stubs to make serial driver happy */
+
 void sercomm_recvchars(void *a) { }
 void sercomm_xmitchars(void *a) { }
 
 /* Stubs to make memory allocator happy */
+
 void cons_puts(void *foo){}
 void delay_ms(int ms){}
 
@@ -61,7 +63,7 @@ void delay_ms(int ms){}
  * Fileops Prototypes and Structures
  ************************************************************************************/
 
-typedef FAR struct file		file_t;
+typedef FAR struct file    file_t;
 
 static ssize_t sc_console_read(file_t *filep, FAR char *buffer, size_t buflen);
 static ssize_t sc_console_write(file_t *filep, FAR const char *buffer, size_t buflen);
@@ -72,26 +74,28 @@ static int     sc_console_poll(file_t *filep, FAR struct pollfd *fds, bool setup
 
 static const struct file_operations g_sercom_console_ops =
 {
-	0,			/* open, always opened */
-	0,			/* close, stays open */
-	sc_console_read,	/* read */
-	sc_console_write,	/* write */
-	0,			/* seek, not supported */
-	sc_console_ioctl,	/* ioctl */
+  0,      /* open, always opened */
+  0,      /* close, stays open */
+  sc_console_read,  /* read */
+  sc_console_write,  /* write */
+  0,      /* seek, not supported */
+  sc_console_ioctl,  /* ioctl */
 #ifndef CONFIG_DISABLE_POLL
-	sc_console_poll		/* poll */
+  sc_console_poll    /* poll */
 #endif
 };
 
+static FAR uart_dev_t *readdev = NULL;
+static struct msgb *recvmsg = NULL;
+
 /****************************************************************************
  * Helper functions
  ****************************************************************************/
-static FAR uart_dev_t *readdev = NULL;
-static struct msgb *recvmsg = NULL;
+
 static void recv_cb(uint8_t dlci, struct msgb *msg)
 {
-	sem_post(&readdev->recvsem);
-	recvmsg = msg;
+  sem_post(&readdev->recvsem);
+  recvmsg = msg;
 }
 
 /****************************************************************************
@@ -101,58 +105,71 @@ static void recv_cb(uint8_t dlci, struct msgb *msg)
 /* XXX: recvmsg is overwritten when multiple msg arrive! */
 static ssize_t sc_console_read(file_t *filep, FAR char *buffer, size_t buflen)
 {
-	size_t len;
-	struct msgb *tmp;
+  size_t len;
+  struct msgb *tmp;
 
-	/* Wait until data is received */
-	while(recvmsg == NULL) {
-		sem_wait(&readdev->recvsem);
-	}
+  /* Wait until data is received */
 
-	len = recvmsg->len > buflen ? buflen : recvmsg->len;
-	memcpy(buffer, msgb_get(recvmsg, len), len);
+  while (recvmsg == NULL)
+    {
+      sem_wait(&readdev->recvsem);
+    }
 
-	if(recvmsg->len == 0) {
-		/* prevent inconsistent msg by first invalidating it, then free it */
-		tmp = recvmsg;
-		recvmsg = NULL;
-		msgb_free(tmp);
-	}
+  len = recvmsg->len > buflen ? buflen : recvmsg->len;
+  memcpy(buffer, msgb_get(recvmsg, len), len);
 
-	return len;
+  if (recvmsg->len == 0)
+    {
+      /* prevent inconsistent msg by first invalidating it, then free it */
+
+      tmp = recvmsg;
+      recvmsg = NULL;
+      msgb_free(tmp);
+    }
+
+  return len;
 }
 
 /* XXX: redirect to old Osmocom-BB comm/sercomm_cons.c -> 2 buffers */
+
 extern int sercomm_puts(const char *s);
+
 static ssize_t sc_console_write(file_t *filep, FAR const char *buffer, size_t buflen)
 {
-	int i, cnt;
-	char dstbuf[32];
+  char dstbuf[32];
+  int cnt;
 
-	if (buflen >= 31)
-		cnt = 31;
-	else
-		cnt = buflen;
+  if (buflen >= 31)
+    {
+      cnt = 31;
+    }
+  else
+    {
+      cnt = buflen;
+    }
 
-        memcpy(dstbuf, buffer, cnt);
-        dstbuf[cnt] = '\0';
+  memcpy(dstbuf, buffer, cnt);
+  dstbuf[cnt] = '\0';
 
-	/* print part of our buffer */
-	sercomm_puts(dstbuf);
+  /* print part of our buffer */
 
-	/* wait a little bit to get data transfered */
-	up_mdelay(1);
+  sercomm_puts(dstbuf);
 
-	return cnt;
+  /* wait a little bit to get data transfered */
+
+  up_mdelay(1);
+
+  return cnt;
 }
 
 /* Forward ioctl to uart driver */
+
 static int sc_console_ioctl(struct file *filep, int cmd, unsigned long arg)
 {
-	FAR struct inode *inode = filep->f_inode;
-	FAR uart_dev_t   *dev   = inode->i_private;
+  FAR struct inode *inode = filep->f_inode;
+  FAR uart_dev_t   *dev   = inode->i_private;
 
-	return dev->ops->ioctl(filep, cmd, arg);
+  return dev->ops->ioctl(filep, cmd, arg);
 }
 
 /************************************************************************************
@@ -160,23 +177,25 @@ static int sc_console_ioctl(struct file *filep, int cmd, unsigned long arg)
  ************************************************************************************/
 
 /* Use sercomm on uart driver, register console driver */
+
 int sercomm_register(FAR const char *path, FAR uart_dev_t *dev)
 {
-	/* XXX: initialize MODEMUART to be used for sercomm*/
-	uart_init(SERCOMM_UART_NR, 1);
-	uart_baudrate(SERCOMM_UART_NR, UART_115200);
-	readdev = dev;
-	sercomm_register_rx_cb(SC_DLCI_LOADER, &recv_cb);
-
-	sem_init(&dev->xmit.sem, 0, 1);
-	sem_init(&dev->recv.sem, 0, 1);
-	sem_init(&dev->closesem, 0, 1);
-	sem_init(&dev->xmitsem,  0, 0);
-	sem_init(&dev->recvsem,  0, 0);
+  /* XXX: initialize MODEMUART to be used for sercomm*/
+
+  uart_init(SERCOMM_UART_NR, 1);
+  uart_baudrate(SERCOMM_UART_NR, UART_115200);
+  readdev = dev;
+  sercomm_register_rx_cb(SC_DLCI_LOADER, &recv_cb);
+
+  sem_init(&dev->xmit.sem, 0, 1);
+  sem_init(&dev->recv.sem, 0, 1);
+  sem_init(&dev->closesem, 0, 1);
+  sem_init(&dev->xmitsem,  0, 0);
+  sem_init(&dev->recvsem,  0, 0);
 #ifndef CONFIG_DISABLE_POLL
-	sem_init(&dev->pollsem,  0, 1);
+  sem_init(&dev->pollsem,  0, 1);
 #endif
 
-	dbg("Registering %s\n", path);
-	return register_driver(path, &g_sercom_console_ops, 0666, NULL);
+  dbg("Registering %s\n", path);
+  return register_driver(path, &g_sercom_console_ops, 0666, NULL);
 }
diff --git a/nuttx/drivers/sercomm/uart.c b/nuttx/drivers/sercomm/uart.c
index 691bba9ec..d64314e25 100644
--- a/nuttx/drivers/sercomm/uart.c
+++ b/nuttx/drivers/sercomm/uart.c
@@ -51,419 +51,563 @@
 
 #include "uart.h"
 
-#define BASE_ADDR_UART_MODEM	0xffff5000
-#define OFFSET_IRDA		0x800
+#define BASE_ADDR_UART_MODEM  0xffff5000
+#define OFFSET_IRDA    0x800
 
-#define UART_REG(n,m)	(BASE_ADDR_UART_MODEM + ((n)*OFFSET_IRDA)+(m))
+#define UART_REG(n,m)  (BASE_ADDR_UART_MODEM + ((n)*OFFSET_IRDA)+(m))
+
+#define LCR7BIT        0x80
+#define LCRBFBIT       0x40
+#define MCR6BIT        0x20
+#define REG_OFFS(m)    ((m) & ~(LCR7BIT|LCRBFBIT|MCR6BIT))
 
-#define LCR7BIT		0x80
-#define LCRBFBIT	0x40
-#define MCR6BIT		0x20
-#define REG_OFFS(m)	((m) & ~(LCR7BIT|LCRBFBIT|MCR6BIT))
 /* read access LCR[7] = 0 */
-enum uart_reg {
-	RHR	= 0,
-	IER	= 1,
-	IIR	= 2,
-	LCR	= 3,
-	MCR	= 4,
-	LSR	= 5,
-	MSR	= 6,
-	SPR	= 7,
-	MDR1	= 8,
-	DMR2	= 9,
-	SFLSR	= 0x0a,
-	RESUME	= 0x0b,
-	SFREGL	= 0x0c,
-	SFREGH	= 0x0d,
-	BLR	= 0x0e,
-	ACREG	= 0x0f,
-	SCR	= 0x10,
-	SSR	= 0x11,
-	EBLR	= 0x12,
-/* read access LCR[7] = 1 */
-	DLL	= RHR | LCR7BIT,
-	DLH	= IER | LCR7BIT,
-	DIV1_6	= ACREG | LCR7BIT,
-/* read/write access LCR[7:0] = 0xbf */
-	EFR	= IIR | LCRBFBIT,
-	XON1	= MCR | LCRBFBIT,
-	XON2	= LSR | LCRBFBIT,
-	XOFF1	= MSR | LCRBFBIT,
-	XOFF2 	= SPR | LCRBFBIT,
-/* read/write access if EFR[4] = 1 and MCR[6] = 1 */
-	TCR	= MSR | MCR6BIT,
-	TLR	= SPR | MCR6BIT,
+
+enum uart_reg
+{
+  RHR  = 0,
+  IER  = 1,
+  IIR  = 2,
+  LCR  = 3,
+  MCR  = 4,
+  LSR  = 5,
+  MSR  = 6,
+  SPR  = 7,
+  MDR1  = 8,
+  DMR2  = 9,
+  SFLSR  = 0x0a,
+  RESUME  = 0x0b,
+  SFREGL  = 0x0c,
+  SFREGH  = 0x0d,
+  BLR  = 0x0e,
+  ACREG  = 0x0f,
+  SCR  = 0x10,
+  SSR  = 0x11,
+  EBLR  = 0x12,
+
+  /* read access LCR[7] = 1 */
+
+  DLL  = RHR | LCR7BIT,
+  DLH  = IER | LCR7BIT,
+  DIV1_6  = ACREG | LCR7BIT,
+
+  /* read/write access LCR[7:0] = 0xbf */
+
+  EFR  = IIR | LCRBFBIT,
+  XON1  = MCR | LCRBFBIT,
+  XON2  = LSR | LCRBFBIT,
+  XOFF1  = MSR | LCRBFBIT,
+  XOFF2   = SPR | LCRBFBIT,
+
+  /* read/write access if EFR[4] = 1 and MCR[6] = 1 */
+
+  TCR  = MSR | MCR6BIT,
+  TLR  = SPR | MCR6BIT,
 };
+
 /* write access LCR[7] = 0 */
-#define THR	RHR
-#define FCR	IIR		/* only if EFR[4] = 1 */
-#define TXFLL	SFLSR
-#define TXFLH	RESUME
-#define RXFLL	SFREGL
-#define RXFLH	SFREGH
-
-enum fcr_bits {
-	FIFO_EN		= (1 << 0),
-	RX_FIFO_CLEAR	= (1 << 1),
-	TX_FIFO_CLEAR	= (1 << 2),
-	DMA_MODE	= (1 << 3),
+
+#define THR    RHR
+#define FCR    IIR    /* only if EFR[4] = 1 */
+#define TXFLL  SFLSR
+#define TXFLH  RESUME
+#define RXFLL  SFREGL
+#define RXFLH  SFREGH
+
+enum fcr_bits
+{
+  FIFO_EN        = (1 << 0),
+  RX_FIFO_CLEAR  = (1 << 1),
+  TX_FIFO_CLEAR  = (1 << 2),
+  DMA_MODE       = (1 << 3),
 };
-#define TX_FIFO_TRIG_SHIFT	4
-#define RX_FIFO_TRIG_SHIFT	6
-
-enum iir_bits {
-	IIR_INT_PENDING			= 0x01,
-	IIR_INT_TYPE			= 0x3E,
-	IIR_INT_TYPE_RX_STATUS_ERROR 	= 0x06,
-	IIR_INT_TYPE_RX_TIMEOUT		= 0x0C,
-	IIR_INT_TYPE_RHR		= 0x04,
-	IIR_INT_TYPE_THR		= 0x02,
-	IIR_INT_TYPE_MSR		= 0x00,
-	IIR_INT_TYPE_XOFF		= 0x10,
-	IIR_INT_TYPE_FLOW		= 0x20,
-	IIR_FCR0_MIRROR			= 0xC0,
+
+#define TX_FIFO_TRIG_SHIFT  4
+#define RX_FIFO_TRIG_SHIFT  6
+
+enum iir_bits
+{
+  IIR_INT_PENDING              = 0x01,
+  IIR_INT_TYPE                 = 0x3E,
+  IIR_INT_TYPE_RX_STATUS_ERROR = 0x06,
+  IIR_INT_TYPE_RX_TIMEOUT      = 0x0C,
+  IIR_INT_TYPE_RHR             = 0x04,
+  IIR_INT_TYPE_THR             = 0x02,
+  IIR_INT_TYPE_MSR             = 0x00,
+  IIR_INT_TYPE_XOFF            = 0x10,
+  IIR_INT_TYPE_FLOW            = 0x20,
+  IIR_FCR0_MIRROR              = 0xC0,
 };
 
-#define UART_REG_UIR	0xffff6000
+#define UART_REG_UIR  0xffff6000
 
 /* enable or disable the divisor latch for access to DLL, DLH */
+
 static void uart_set_lcr7bit(int uart, int on)
 {
-	uint8_t reg;
-
-	reg = readb(UART_REG(uart, LCR));
-	if (on)
-		reg |= (1 << 7);
-	else
-		reg &= ~(1 << 7);
-	writeb(reg, UART_REG(uart, LCR));
+  uint8_t reg;
+
+  reg = readb(UART_REG(uart, LCR));
+  if (on)
+    {
+      reg |= (1 << 7);
+    }
+  else
+    {
+      reg &= ~(1 << 7);
+    }
+
+  writeb(reg, UART_REG(uart, LCR));
 }
 
 static uint8_t old_lcr;
 static void uart_set_lcr_bf(int uart, int on)
 {
-	if (on) {
-		old_lcr = readb(UART_REG(uart, LCR));
-		writeb(0xBF, UART_REG(uart, LCR));
-	} else {
-		writeb(old_lcr, UART_REG(uart, LCR));
-	}
+  if (on)
+    {
+      old_lcr = readb(UART_REG(uart, LCR));
+      writeb(0xBF, UART_REG(uart, LCR));
+    }
+  else
+    {
+      writeb(old_lcr, UART_REG(uart, LCR));
+    }
 }
 
 /* Enable or disable the TCR_TLR latch bit in MCR[6] */
+
 static void uart_set_mcr6bit(int uart, int on)
 {
-	uint8_t mcr;
-	/* we assume EFR[4] is always set to 1 */
-	mcr = readb(UART_REG(uart, MCR));
-	if (on)
-		mcr |= (1 << 6);
-	else
-		mcr &= ~(1 << 6);
-	writeb(mcr, UART_REG(uart, MCR));
+  uint8_t mcr;
+
+  /* we assume EFR[4] is always set to 1 */
+
+  mcr = readb(UART_REG(uart, MCR));
+  if (on)
+    {
+      mcr |= (1 << 6);
+    }
+  else
+    {
+      mcr &= ~(1 << 6);
+    }
+
+  writeb(mcr, UART_REG(uart, MCR));
 }
 
 static void uart_reg_write(int uart, enum uart_reg reg, uint8_t val)
 {
-	if (reg & LCRBFBIT)
-		uart_set_lcr_bf(uart, 1);
-	else if (reg & LCR7BIT)
-		uart_set_lcr7bit(uart, 1);
-	else if (reg & MCR6BIT)
-		uart_set_mcr6bit(uart, 1);
-
-	writeb(val, UART_REG(uart, REG_OFFS(reg)));
-
-	if (reg & LCRBFBIT)
-		uart_set_lcr_bf(uart, 0);
-	else if (reg & LCR7BIT)
-		uart_set_lcr7bit(uart, 0);
-	else if (reg & MCR6BIT)
-		uart_set_mcr6bit(uart, 0);
+  if (reg & LCRBFBIT)
+    {
+      uart_set_lcr_bf(uart, 1);
+    }
+  else if (reg & LCR7BIT)
+    {
+      uart_set_lcr7bit(uart, 1);
+    }
+  else if (reg & MCR6BIT)
+    {
+      uart_set_mcr6bit(uart, 1);
+    }
+
+  writeb(val, UART_REG(uart, REG_OFFS(reg)));
+
+  if (reg & LCRBFBIT)
+    {
+      uart_set_lcr_bf(uart, 0);
+    }
+  else if (reg & LCR7BIT)
+    {
+      uart_set_lcr7bit(uart, 0);
+    }
+  else if (reg & MCR6BIT)
+    {
+      uart_set_mcr6bit(uart, 0);
+    }
 }
 
 /* read from a UART register, applying any required latch bits */
+
 static uint8_t uart_reg_read(int uart, enum uart_reg reg)
 {
-	uint8_t ret;
-
-	if (reg & LCRBFBIT)
-		uart_set_lcr_bf(uart, 1);
-	else if (reg & LCR7BIT)
-		uart_set_lcr7bit(uart, 1);
-	else if (reg & MCR6BIT)
-		uart_set_mcr6bit(uart, 1);
-
-	ret = readb(UART_REG(uart, REG_OFFS(reg)));
-
-	if (reg & LCRBFBIT)
-		uart_set_lcr_bf(uart, 0);
-	else if (reg & LCR7BIT)
-		uart_set_lcr7bit(uart, 0);
-	else if (reg & MCR6BIT)
-		uart_set_mcr6bit(uart, 0);
-
-	return ret;
+  uint8_t ret;
+
+  if (reg & LCRBFBIT)
+    {
+     uart_set_lcr_bf(uart, 1);
+    }
+  else if (reg & LCR7BIT)
+    {
+      uart_set_lcr7bit(uart, 1);
+    }
+  else if (reg & MCR6BIT)
+    {
+      uart_set_mcr6bit(uart, 1);
+    }
+
+  ret = readb(UART_REG(uart, REG_OFFS(reg)));
+
+  if (reg & LCRBFBIT)
+    {
+      uart_set_lcr_bf(uart, 0);
+    }
+  else if (reg & LCR7BIT)
+    {
+      uart_set_lcr7bit(uart, 0);
+    }
+  else if (reg & MCR6BIT)
+    {
+      uart_set_mcr6bit(uart, 0);
+    }
+
+  return ret;
 }
 
 #if 0
 static void uart_irq_handler_cons(__unused enum irq_nr irqnr)
 {
-	const uint8_t uart = CONS_UART_NR;
-	uint8_t iir;
-
-	//uart_putchar_nb(uart, 'U');
-
-	iir = uart_reg_read(uart, IIR);
-	if (iir & IIR_INT_PENDING)
-		return;
-
-	switch (iir & IIR_INT_TYPE) {
-	case IIR_INT_TYPE_RHR:
-		break;
-	case IIR_INT_TYPE_THR:
-		if (cons_rb_flush() == 1) {
-			/* everything was flushed, disable THR IRQ */
-			uint8_t ier = uart_reg_read(uart, IER);
-			ier &= ~(1 << 1);
-			uart_reg_write(uart, IER, ier);
-		}
-		break;
-	case IIR_INT_TYPE_MSR:
-		break;
-	case IIR_INT_TYPE_RX_STATUS_ERROR:
-		break;
-	case IIR_INT_TYPE_RX_TIMEOUT:
-		break;
-	case IIR_INT_TYPE_XOFF:
-		break;
-	}
+  const uint8_t uart = CONS_UART_NR;
+  uint8_t iir;
+
+  //uart_putchar_nb(uart, 'U');
+
+  iir = uart_reg_read(uart, IIR);
+  if (iir & IIR_INT_PENDING)
+    {
+      return;
+    }
+
+  switch (iir & IIR_INT_TYPE)
+    {
+    case IIR_INT_TYPE_RHR:
+      break;
+
+    case IIR_INT_TYPE_THR:
+      if (cons_rb_flush() == 1)
+        {
+          /* everything was flushed, disable THR IRQ */
+
+          uint8_t ier = uart_reg_read(uart, IER);
+          ier &= ~(1 << 1);
+          uart_reg_write(uart, IER, ier);
+        }
+      break;
+
+    case IIR_INT_TYPE_MSR:
+      break;
+
+    case IIR_INT_TYPE_RX_STATUS_ERROR:
+      break;
+
+    case IIR_INT_TYPE_RX_TIMEOUT:
+      break;
+
+    case IIR_INT_TYPE_XOFF:
+      break;
+  }
 }
 #endif
 
 static void uart_irq_handler_sercomm(__unused enum irq_nr irqnr, __unused void *context)
 {
-	const uint8_t uart = SERCOMM_UART_NR;
-	uint8_t iir, ch;
-
-	//uart_putchar_nb(uart, 'U');
-
-	iir = uart_reg_read(uart, IIR);
-	if (iir & IIR_INT_PENDING)
-		return;
-
-	switch (iir & IIR_INT_TYPE) {
-	case IIR_INT_TYPE_RX_TIMEOUT:
-	case IIR_INT_TYPE_RHR:
-		/* as long as we have rx data available */
-		while (uart_getchar_nb(uart, &ch)) {
-			if (sercomm_drv_rx_char(ch) < 0) {
-				/* sercomm cannot receive more data right now */
-				uart_irq_enable(uart, UART_IRQ_RX_CHAR, 0);
-			}
-		}
-		break;
-	case IIR_INT_TYPE_THR:
-		/* as long as we have space in the FIFO */
-		while (!uart_tx_busy(uart)) {
-			/* get a byte from sercomm */
-			if (!sercomm_drv_pull(&ch)) {
-				/* no more bytes in sercomm, stop TX interrupts */
-				uart_irq_enable(uart, UART_IRQ_TX_EMPTY, 0);
-				break;
-			}
-			/* write the byte into the TX FIFO */
-			uart_putchar_nb(uart, ch);
-		}
-		break;
-	case IIR_INT_TYPE_MSR:
-		printf("UART IRQ MSR\n");
-		break;
-	case IIR_INT_TYPE_RX_STATUS_ERROR:
-		printf("UART IRQ RX_SE\n");
-		break;
-	case IIR_INT_TYPE_XOFF:
-		printf("UART IRQXOFF\n");
-		break;
-	}
+  const uint8_t uart = SERCOMM_UART_NR;
+  uint8_t iir, ch;
+
+  //uart_putchar_nb(uart, 'U');
+
+  iir = uart_reg_read(uart, IIR);
+  if (iir & IIR_INT_PENDING)
+    {
+      return;
+    }
+
+  switch (iir & IIR_INT_TYPE)
+    {
+    case IIR_INT_TYPE_RX_TIMEOUT:
+    case IIR_INT_TYPE_RHR:
+      /* as long as we have rx data available */
+
+      while (uart_getchar_nb(uart, &ch))
+        {
+          if (sercomm_drv_rx_char(ch) < 0)
+            {
+              /* sercomm cannot receive more data right now */
+
+              uart_irq_enable(uart, UART_IRQ_RX_CHAR, 0);
+            }
+        }
+      break;
+
+    case IIR_INT_TYPE_THR:
+      /* as long as we have space in the FIFO */
+
+      while (!uart_tx_busy(uart))
+        {
+          /* get a byte from sercomm */
+
+          if (!sercomm_drv_pull(&ch))
+            {
+              /* no more bytes in sercomm, stop TX interrupts */
+
+              uart_irq_enable(uart, UART_IRQ_TX_EMPTY, 0);
+              break;
+            }
+
+          /* write the byte into the TX FIFO */
+
+          uart_putchar_nb(uart, ch);
+        }
+      break;
+
+    case IIR_INT_TYPE_MSR:
+      printf("UART IRQ MSR\n");
+      break;
+
+    case IIR_INT_TYPE_RX_STATUS_ERROR:
+      printf("UART IRQ RX_SE\n");
+      break;
+
+    case IIR_INT_TYPE_XOFF:
+      printf("UART IRQXOFF\n");
+      break;
+    }
 }
 
-static const uint8_t uart2irq[] = {
-	[0]	= IRQ_UART_IRDA,
-	[1]	= IRQ_UART_MODEM,
+static const uint8_t uart2irq[] =
+{
+  [0]  = IRQ_UART_IRDA,
+  [1]  = IRQ_UART_MODEM,
 };
 
 void uart_init(uint8_t uart, uint8_t interrupts)
 {
-	uint8_t irq = uart2irq[uart];
+#if 0
+  uint8_t irq = uart2irq[uart];
+#endif
 
-	uart_reg_write(uart, IER, 0x00);
+  uart_reg_write(uart, IER, 0x00);
 
-	if (uart == SERCOMM_UART_NR) {
-		sercomm_init();
-		irq_attach(IRQ_UART_MODEM, (xcpt_t)uart_irq_handler_sercomm);
-		up_enable_irq(IRQ_UART_MODEM);
-		uart_irq_enable(uart, UART_IRQ_RX_CHAR, 1);
-	}
+  if (uart == SERCOMM_UART_NR)
+    {
+      sercomm_init();
+      irq_attach(IRQ_UART_MODEM, (xcpt_t)uart_irq_handler_sercomm);
+      up_enable_irq(IRQ_UART_MODEM);
+      uart_irq_enable(uart, UART_IRQ_RX_CHAR, 1);
+    }
 
 #if 0
-	if (uart == CONS_UART_NR) {
-		cons_init();
-		if(interrupts) {
-			irq_register_handler(irq, &uart_irq_handler_cons);
-			irq_config(irq, 0, 0, 0xff);
-			irq_enable(irq);
-		}
-	} else {
-		sercomm_init();
-		if(interrupts) {
-			irq_register_handler(irq, &uart_irq_handler_sercomm);
-			irq_config(irq, 0, 0, 0xff);
-			irq_enable(irq);
-		}
-		uart_irq_enable(uart, UART_IRQ_RX_CHAR, 1);
-	}
+  if (uart == CONS_UART_NR)
+    {
+      cons_init();
+      if(interrupts)
+        {
+          irq_register_handler(irq, &uart_irq_handler_cons);
+          irq_config(irq, 0, 0, 0xff);
+          irq_enable(irq);
+        }
+    }
+  else
+    {
+      sercomm_init();
+      if(interrupts)
+        {
+          irq_register_handler(irq, &uart_irq_handler_sercomm);
+          irq_config(irq, 0, 0, 0xff);
+          irq_enable(irq);
+        }
+
+      uart_irq_enable(uart, UART_IRQ_RX_CHAR, 1);
+    }
 #endif
 #if 0
-	if (uart == 1) {
-		/* assign UART to MCU and unmask interrupts*/
-		writeb(UART_REG_UIR, 0x00);
-	}
+  if (uart == 1)
+    {
+      /* assign UART to MCU and unmask interrupts*/
+
+      writeb(UART_REG_UIR, 0x00);
+    }
 #endif
 
-	/* if we don't initialize these, we get strange corruptions in the
-	   received data... :-( */
-	uart_reg_write(uart,  MDR1, 0x07); /* turn off UART */
-	uart_reg_write(uart,  XON1, 0x00); /* Xon1/Addr Register */
-	uart_reg_write(uart,  XON2, 0x00); /* Xon2/Addr Register */
-	uart_reg_write(uart, XOFF1, 0x00); /* Xoff1 Register */
-	uart_reg_write(uart, XOFF2, 0x00); /* Xoff2 Register */
-	uart_reg_write(uart,   EFR, 0x00); /* Enhanced Features Register */
-
-	/* select  UART mode */
-	uart_reg_write(uart, MDR1, 0);
-	/* no XON/XOFF flow control, ENHANCED_EN, no auto-RTS/CTS */
-	uart_reg_write(uart, EFR, (1 << 4));
-	/* enable Tx/Rx FIFO, Tx trigger at 56 spaces, Rx trigger at 60 chars */
-	uart_reg_write(uart, FCR, FIFO_EN | RX_FIFO_CLEAR | TX_FIFO_CLEAR |
-			(3 << TX_FIFO_TRIG_SHIFT) | (3 << RX_FIFO_TRIG_SHIFT));
-
-	/* THR interrupt only when TX FIFO and TX shift register are empty */
-	uart_reg_write(uart, SCR, (1 << 0));// | (1 << 3));
-
-	/* 8 bit, 1 stop bit, no parity, no break */
-	uart_reg_write(uart, LCR, 0x03);
-
-	uart_set_lcr7bit(uart, 0);
+  /* if we don't initialize these, we get strange corruptions in the
+   * received data... :-(
+   */
+
+  uart_reg_write(uart,  MDR1, 0x07); /* turn off UART */
+  uart_reg_write(uart,  XON1, 0x00); /* Xon1/Addr Register */
+  uart_reg_write(uart,  XON2, 0x00); /* Xon2/Addr Register */
+  uart_reg_write(uart, XOFF1, 0x00); /* Xoff1 Register */
+  uart_reg_write(uart, XOFF2, 0x00); /* Xoff2 Register */
+  uart_reg_write(uart,   EFR, 0x00); /* Enhanced Features Register */
+
+  /* select  UART mode */
+
+  uart_reg_write(uart, MDR1, 0);
+
+  /* no XON/XOFF flow control, ENHANCED_EN, no auto-RTS/CTS */
+
+  uart_reg_write(uart, EFR, (1 << 4));
+
+  /* enable Tx/Rx FIFO, Tx trigger at 56 spaces, Rx trigger at 60 chars */
+
+  uart_reg_write(uart, FCR, FIFO_EN | RX_FIFO_CLEAR | TX_FIFO_CLEAR |
+                (3 << TX_FIFO_TRIG_SHIFT) | (3 << RX_FIFO_TRIG_SHIFT));
+
+  /* THR interrupt only when TX FIFO and TX shift register are empty */
+
+  uart_reg_write(uart, SCR, (1 << 0));// | (1 << 3));
+
+  /* 8 bit, 1 stop bit, no parity, no break */
+
+  uart_reg_write(uart, LCR, 0x03);
+
+  uart_set_lcr7bit(uart, 0);
 }
 
-void uart_poll(uint8_t uart) {
-/*	if(uart == CONS_UART_NR) {
-		uart_irq_handler_cons(0);
-	} else
-*/	{
-		uart_irq_handler_sercomm(0, NULL);
-	}
+void uart_poll(uint8_t uart)
+{
+#if 0
+  if (uart == CONS_UART_NR)
+    {
+      uart_irq_handler_cons(0);
+    }
+  else
+#endif
+    {
+      uart_irq_handler_sercomm(0, NULL);
+    }
 }
 
 void uart_irq_enable(uint8_t uart, enum uart_irq irq, int on)
 {
-	uint8_t ier = uart_reg_read(uart, IER);
-	uint8_t mask = 0;
-
-	switch (irq) {
-	case UART_IRQ_TX_EMPTY:
-		mask = (1 << 1);
-		break;
-	case UART_IRQ_RX_CHAR:
-		mask = (1 << 0);
-		break;
-	}
-
-	if (on)
-		ier |= mask;
-	else
-		ier &= ~mask;
-
-	uart_reg_write(uart, IER, ier);
+  uint8_t ier = uart_reg_read(uart, IER);
+  uint8_t mask = 0;
+
+  switch (irq)
+    {
+    case UART_IRQ_TX_EMPTY:
+      mask = (1 << 1);
+      break;
+
+    case UART_IRQ_RX_CHAR:
+      mask = (1 << 0);
+      break;
+    }
+
+  if (on)
+    {
+      ier |= mask;
+    }
+  else
+    {
+      ier &= ~mask;
+    }
+
+  uart_reg_write(uart, IER, ier);
 }
 
-
 void uart_putchar_wait(uint8_t uart, int c)
 {
-	/* wait while TX FIFO indicates full */
-	while (readb(UART_REG(uart, SSR)) & 0x01) { }
+  /* wait while TX FIFO indicates full */
+
+  while (readb(UART_REG(uart, SSR)) & 0x01) { }
 
-	/* put character in TX FIFO */
-	writeb(c, UART_REG(uart, THR));
+  /* put character in TX FIFO */
+
+  writeb(c, UART_REG(uart, THR));
 }
 
 int uart_putchar_nb(uint8_t uart, int c)
 {
-	/* if TX FIFO indicates full, abort */
-	if (readb(UART_REG(uart, SSR)) & 0x01)
-		return 0;
+  /* if TX FIFO indicates full, abort */
+
+  if (readb(UART_REG(uart, SSR)) & 0x01)
+    {
+      return 0;
+    }
 
-	writeb(c, UART_REG(uart, THR));
-	return 1;
+  writeb(c, UART_REG(uart, THR));
+  return 1;
 }
 
 int uart_getchar_nb(uint8_t uart, uint8_t *ch)
 {
-	uint8_t lsr;
-
-	lsr = readb(UART_REG(uart, LSR));
-
-	/* something strange happened */
-	if (lsr & 0x02)
-		printf("LSR RX_OE\n");
-	if (lsr & 0x04)
-		printf("LSR RX_PE\n");
-	if (lsr & 0x08)
-		printf("LSR RX_FE\n");
-	if (lsr & 0x10)
-		printf("LSR RX_BI\n");
-	if (lsr & 0x80)
-		printf("LSR RX_FIFO_STS\n");
-
-	/* is the Rx FIFO empty? */
-	if (!(lsr & 0x01))
-		return 0;
-
-	*ch = readb(UART_REG(uart, RHR));
-	//printf("getchar_nb(%u) = %02x\n", uart, *ch);
-	return 1;
+  uint8_t lsr;
+
+  lsr = readb(UART_REG(uart, LSR));
+
+  /* something strange happened */
+
+  if (lsr & 0x02)
+    {
+      printf("LSR RX_OE\n");
+    }
+
+  if (lsr & 0x04)
+    {
+      printf("LSR RX_PE\n");
+    }
+
+  if (lsr & 0x08)
+    {
+      printf("LSR RX_FE\n");
+    }
+
+  if (lsr & 0x10)
+    {
+      printf("LSR RX_BI\n");
+    }
+
+  if (lsr & 0x80)
+    {
+      printf("LSR RX_FIFO_STS\n");
+    }
+
+  /* is the Rx FIFO empty? */
+
+  if (!(lsr & 0x01))
+    {
+      return 0;
+    }
+
+  *ch = readb(UART_REG(uart, RHR));
+  //printf("getchar_nb(%u) = %02x\n", uart, *ch);
+  return 1;
 }
 
 int uart_tx_busy(uint8_t uart)
 {
-	if (readb(UART_REG(uart, SSR)) & 0x01)
-		return 1;
-	return 0;
+  if (readb(UART_REG(uart, SSR)) & 0x01)
+    {
+      return 1;
+    }
+
+  return 0;
 }
 
-static const uint16_t divider[] = {
-	[UART_38400]	= 21,	/*   38,690 */
-	[UART_57600]	= 14,	/*   58,035 */
-	[UART_115200]	= 7,	/*  116,071 */
-	[UART_230400]	= 4,	/*  203,125! (-3% would be 223,488) */
-	[UART_460800]	= 2,	/*  406,250! (-3% would be 446,976) */
-	[UART_921600]	= 1,	/*  812,500! (-3% would be 893,952) */
+static const uint16_t divider[] =
+{
+  [UART_38400]  = 21,  /*   38,690 */
+  [UART_57600]  = 14,  /*   58,035 */
+  [UART_115200]  = 7,  /*  116,071 */
+  [UART_230400]  = 4,  /*  203,125! (-3% would be 223,488) */
+  [UART_460800]  = 2,  /*  406,250! (-3% would be 446,976) */
+  [UART_921600]  = 1,  /*  812,500! (-3% would be 893,952) */
 };
 
 int uart_baudrate(uint8_t uart, enum uart_baudrate bdrt)
 {
-	uint16_t div;
+  uint16_t div;
 
-	if (bdrt > ARRAY_SIZE(divider))
-		return -1;
+  if (bdrt > ARRAY_SIZE(divider))
+    {
+      return -1;
+    }
 
-	div = divider[bdrt];
-	uart_set_lcr7bit(uart, 1);
-	writeb(div & 0xff, UART_REG(uart, DLL));
-	writeb(div >> 8, UART_REG(uart, DLH));
-	uart_set_lcr7bit(uart, 0);
+  div = divider[bdrt];
+  uart_set_lcr7bit(uart, 1);
+  writeb(div & 0xff, UART_REG(uart, DLL));
+  writeb(div >> 8, UART_REG(uart, DLH));
+  uart_set_lcr7bit(uart, 0);
 
-	return 0;
+  return 0;
 }
diff --git a/nuttx/drivers/syslog/ramlog.c b/nuttx/drivers/syslog/ramlog.c
index 08bbbfb59..47b0cd3cb 100644
--- a/nuttx/drivers/syslog/ramlog.c
+++ b/nuttx/drivers/syslog/ramlog.c
@@ -692,11 +692,10 @@ int ramlog_register(FAR const char *devpath, FAR char *buffer, size_t buflen)
 int ramlog_consoleinit(void)
 {
   FAR struct ramlog_dev_s *priv = &g_sysdev;
-  int ret;
 
   /* Register the console character driver */
 
-  ret = register_driver("/dev/console", &g_ramlogfops, 0666, priv);
+  return register_driver("/dev/console", &g_ramlogfops, 0666, priv);
 }
 #endif
 
@@ -738,11 +737,11 @@ int ramlog_sysloginit(void)
 int syslog_putc(int ch)
 {
   FAR struct ramlog_dev_s *priv = &g_sysdev;
+#ifdef CONFIG_RAMLOG_CRLF
   int ret;
 
   /* Ignore carriage returns */
 
-#ifdef CONFIG_RAMLOG_CRLF
   if (ch == '\r')
     {
       return ch;
diff --git a/nuttx/drivers/usbdev/usbmsc.c b/nuttx/drivers/usbdev/usbmsc.c
index 5b46bfac3..5881419aa 100644
--- a/nuttx/drivers/usbdev/usbmsc.c
+++ b/nuttx/drivers/usbdev/usbmsc.c
@@ -1384,7 +1384,7 @@ int usbmsc_bindlun(FAR void *handle, FAR const char *drvrpath,
   int ret;
 
 #ifdef CONFIG_DEBUG
-  if (!alloc || !drvrpath || startsector < 0 || nsectors < 0)
+  if (!alloc || !drvrpath || startsector < 0)
     {
       usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BINLUNINVALIDARGS1), 0);
       return -EINVAL;
@@ -1722,11 +1722,9 @@ void usbmsc_uninitialize(FAR void *handle)
   FAR struct usbmsc_alloc_s *alloc = (FAR struct usbmsc_alloc_s *)handle;
   FAR struct usbmsc_dev_s *priv;
   irqstate_t flags;
-#ifdef SDCC
-  pthread_addr_t result1, result2;
-  pthread_attr_t attr;
-#endif
+#if 0
   void *value;
+#endif
   int i;
 
 #ifdef CONFIG_DEBUG
diff --git a/nuttx/drivers/usbdev/usbmsc_desc.c b/nuttx/drivers/usbdev/usbmsc_desc.c
index 81e188dab..87fe6d040 100644
--- a/nuttx/drivers/usbdev/usbmsc_desc.c
+++ b/nuttx/drivers/usbdev/usbmsc_desc.c
@@ -360,7 +360,7 @@ int16_t usbmsc_mkcfgdesc(uint8_t *buf)
 {
 #ifdef CONFIG_USBDEV_DUALSPEED
   FAR const struct usb_epdesc_s *epdesc;
-  bool hispeed = (speed == USB_SPEED_HIGH);
+  bool hispeed;
 #endif
 
   /* Configuration descriptor.  If the USB mass storage device is
diff --git a/nuttx/drivers/wireless/cc3000/cc3000.c b/nuttx/drivers/wireless/cc3000/cc3000.c
index 8e3b03c23..b051578cc 100644
--- a/nuttx/drivers/wireless/cc3000/cc3000.c
+++ b/nuttx/drivers/wireless/cc3000/cc3000.c
@@ -1292,7 +1292,7 @@ static int cc3000_poll(FAR struct file *filep, FAR struct pollfd *fds,
 {
   FAR struct inode *inode;
   FAR struct cc3000_dev_s *priv;
-  int ret = OK;
+  int ret;
   int i;
 
   nllvdbg("setup: %d\n", (int)setup);
diff --git a/nuttx/drivers/wireless/cc3000/socket.c b/nuttx/drivers/wireless/cc3000/socket.c
index 006c34cfd..aa67d8606 100644
--- a/nuttx/drivers/wireless/cc3000/socket.c
+++ b/nuttx/drivers/wireless/cc3000/socket.c
@@ -186,6 +186,7 @@ int cc3000_socket(int domain, int type, int protocol)
 int cc3000_closesocket(int sockfd)
 {
   int ret;
+
   cc3000_lib_lock();
   ret = cc3000_closesocket_impl(sockfd);
 #ifdef CONFIG_CC3000_MT
@@ -243,6 +244,7 @@ int cc3000_closesocket(int sockfd)
 int cc3000_do_accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
 {
   int ret;
+
   cc3000_lib_lock();
   ret = cc3000_accept_impl(sockfd, addr, addrlen);
   cc3000_lib_unlock();
@@ -265,8 +267,6 @@ int cc3000_accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
 }
 #else
 {
-  int ret = OK;
-
   cc3000_accept_socket(sockfd,0);
   short nonBlocking=CC3000_SOCK_OFF;
 
@@ -306,7 +306,7 @@ int cc3000_accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
 
 int cc3000_bind(int sockfd, FAR const struct sockaddr *addr, socklen_t addrlen)
 {
-  int ret = OK;
+  int ret;
 
   cc3000_lib_lock();
   ret = cc3000_bind_impl(sockfd, addr, addrlen);
@@ -340,7 +340,7 @@ int cc3000_bind(int sockfd, FAR const struct sockaddr *addr, socklen_t addrlen)
 
 int cc3000_listen(int sockfd, int backlog)
 {
-  int ret = OK;
+  int ret;
 
   cc3000_lib_lock();
   ret = cc3000_listen_impl(sockfd,backlog);
@@ -380,7 +380,7 @@ int cc3000_listen(int sockfd, int backlog)
 
 int cc3000_connect(int sockfd, FAR const struct sockaddr *addr, socklen_t addrlen)
 {
-  int ret = OK;
+  int ret;
 
   cc3000_lib_lock();
   ret = cc3000_connect_impl(sockfd, addr, addrlen);
@@ -430,7 +430,7 @@ int cc3000_connect(int sockfd, FAR const struct sockaddr *addr, socklen_t addrle
 int cc3000_select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds,
            struct timeval *timeout)
 {
-  int ret = OK;
+  int ret;
 
   cc3000_lib_lock();
   ret = cc3000_select_impl(nfds, (TICC3000fd_set *)readfds,
@@ -492,7 +492,7 @@ int cc3000_select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds,
 int cc3000_setsockopt(int sockfd, int level, int option,
                       FAR const void *value, socklen_t value_len)
 {
-  int ret = OK;
+  int ret;
 
   cc3000_lib_lock();
   ret = cc3000_setsockopt_impl(sockfd, level, option, value, value_len);
@@ -552,7 +552,7 @@ int cc3000_setsockopt(int sockfd, int level, int option,
 int cc3000_getsockopt(int sockfd, int level, int option, FAR void *value,
                       FAR socklen_t *value_len)
 {
-  int ret = OK;
+  int ret;
 
   cc3000_lib_lock();
   ret = cc3000_getsockopt_impl(sockfd, level, option, value, value_len);
@@ -584,7 +584,7 @@ int cc3000_getsockopt(int sockfd, int level, int option, FAR void *value,
 
 ssize_t cc3000_recv(int sockfd, FAR void *buf, size_t len, int flags)
 {
-  ssize_t ret = OK;
+  ssize_t ret;
 
 #ifdef CONFIG_CC3000_MT
   ret = cc3000_wait_data(sockfd);
@@ -632,7 +632,7 @@ ssize_t cc3000_recv(int sockfd, FAR void *buf, size_t len, int flags)
 ssize_t cc3000_recvfrom(int sockfd, FAR void *buf, size_t len, int flags,
                         FAR struct sockaddr *from, FAR socklen_t *fromlen)
 {
-  ssize_t ret = OK;
+  ssize_t ret;
 
 #ifdef CONFIG_CC3000_MT
   ret = cc3000_wait_data(sockfd);
@@ -672,7 +672,7 @@ ssize_t cc3000_recvfrom(int sockfd, FAR void *buf, size_t len, int flags,
 
 ssize_t cc3000_send(int sockfd, FAR const void *buf, size_t len, int flags)
 {
-  ssize_t ret = OK;
+  ssize_t ret;
 
   cc3000_lib_lock();
   ret = cc3000_send_impl(sockfd, buf, len, flags);
@@ -709,7 +709,7 @@ ssize_t cc3000_send(int sockfd, FAR const void *buf, size_t len, int flags)
 ssize_t cc3000_sendto(int sockfd, FAR const void *buf, size_t len, int flags,
                       FAR const struct sockaddr *to, socklen_t tolen)
 {
-  ssize_t ret = OK;
+  ssize_t ret;
 
   cc3000_lib_lock();
   ret = cc3000_sendto_impl(sockfd, buf, len, flags, to, tolen);
@@ -744,7 +744,7 @@ ssize_t cc3000_sendto(int sockfd, FAR const void *buf, size_t len, int flags,
 // TODO: Standard is struct hostent *gethostbyname(const char *name);
 int cc3000_gethostbyname(char * hostname, uint16_t usNameLen, unsigned long* out_ip_addr)
 {
-  int ret = OK;
+  int ret;
 
   cc3000_lib_lock();
   ret = cc3000_gethostbyname_impl(hostname, usNameLen, out_ip_addr);
@@ -775,7 +775,7 @@ int cc3000_mdnsadvertiser(uint16_t mdnsEnabled, char *deviceServiceName,
                           uint16_t deviceServiceNameLength)
 
 {
-  int ret = OK;
+  int ret;
 
   cc3000_lib_lock();
   ret = cc3000_mdnsadvertiser_impl(mdnsEnabled, deviceServiceName, deviceServiceNameLength);
diff --git a/nuttx/drivers/wireless/cc3000/socket_imp.c b/nuttx/drivers/wireless/cc3000/socket_imp.c
index 262135b65..8ebc16d3f 100644
--- a/nuttx/drivers/wireless/cc3000/socket_imp.c
+++ b/nuttx/drivers/wireless/cc3000/socket_imp.c
@@ -135,9 +135,9 @@ int HostFlowControlConsumeBuff(int sd)
 
       if (tSLInformation.slTransmitDataError != 0)
         {
-          errno = tSLInformation.slTransmitDataError;
+          set_errno(tSLInformation.slTransmitDataError);
           tSLInformation.slTransmitDataError = 0;
-          return errno;
+          return tSLInformation.slTransmitDataError;
         }
 
       if (SOCKET_STATUS_ACTIVE != get_socket_active_status(sd))
@@ -165,9 +165,9 @@ int HostFlowControlConsumeBuff(int sd)
 
   if (tSLInformation.slTransmitDataError != 0)
     {
-      errno = tSLInformation.slTransmitDataError;
+      set_errno(tSLInformation.slTransmitDataError);
       tSLInformation.slTransmitDataError = 0;
-      return errno;
+      return tSLInformation.slTransmitDataError;
     }
 
   if (SOCKET_STATUS_ACTIVE != get_socket_active_status(sd))
@@ -240,10 +240,8 @@ int cc3000_socket_impl(long domain, long type, long protocol)
 
   /* Process the event */
 
-  errno = ret;
-
+  set_errno(ret);
   set_socket_active_status(ret, SOCKET_STATUS_ACTIVE);
-
   return ret;
 }
 
@@ -282,7 +280,7 @@ long cc3000_closesocket_impl(long sd)
   /* Since we are in blocking state - wait for event complete */
 
   SimpleLinkWaitEvent(HCI_CMND_CLOSE_SOCKET, &ret);
-  errno = ret;
+  set_errno(ret);
 
   /* Since 'close' call may result in either OK (and then it closed) or error
    * mark this socket as invalid
@@ -344,7 +342,6 @@ long cc3000_accept_impl(long sd, struct sockaddr *addr, socklen_t *addrlen)
   uint8_t *ptr, *args;
   tBsdReturnParams tAcceptReturnArguments;
 
-  ret = EFAIL;
   ptr = tSLInformation.pucTxCommandBuffer;
   args = (ptr + HEADERS_SIZE_CMD);
 
@@ -366,8 +363,8 @@ long cc3000_accept_impl(long sd, struct sockaddr *addr, socklen_t *addrlen)
 
   memcpy(addr, &tAcceptReturnArguments.tSocketAddress, CC3000_ASIC_ADDR_LEN);
   *addrlen = CC3000_ASIC_ADDR_LEN;
-  errno = tAcceptReturnArguments.iStatus;
-  ret = errno;
+  set_errno(tAcceptReturnArguments.iStatus);
+  ret = tAcceptReturnArguments.iStatus;
 
   /* if succeeded, iStatus = new socket descriptor. otherwise - error number */
 
@@ -433,8 +430,7 @@ long cc3000_bind_impl(long sd, const struct sockaddr *addr, socklen_t addrlen)
 
   SimpleLinkWaitEvent(HCI_CMND_BIND, &ret);
 
-  errno = ret;
-
+  set_errno(ret);
   return ret;
 }
 
@@ -484,8 +480,8 @@ long cc3000_listen_impl(long sd, long backlog)
   /* Since we are in blocking state - wait for event complete */
 
   SimpleLinkWaitEvent(HCI_CMND_LISTEN, &ret);
-  errno = ret;
 
+  set_errno(ret);
   return ret;
 }
 
@@ -518,11 +514,11 @@ int cc3000_gethostbyname_impl(char * hostname, uint16_t usNameLen, unsigned long
   tBsdGethostbynameParams ret;
   uint8_t *ptr, *args;
 
-  errno = EFAIL;
+  set_errno(EFAIL);
 
   if (usNameLen > CC3000_HOSTNAME_MAX_LENGTH)
     {
-      return errno;
+      return get_errno();
     }
 
   ptr = tSLInformation.pucTxCommandBuffer;
@@ -543,11 +539,11 @@ int cc3000_gethostbyname_impl(char * hostname, uint16_t usNameLen, unsigned long
 
   SimpleLinkWaitEvent(HCI_EVNT_BSD_GETHOSTBYNAME, &ret);
 
-  errno = ret.retVal;
+  set_errno(ret.retVal);
 
   (*((long*)out_ip_addr)) = ret.outputAddress;
 
-  return errno;
+  return ret.retVal;
 }
 #endif
 
@@ -607,8 +603,7 @@ long cc3000_connect_impl(long sd, const struct sockaddr *addr, socklen_t addrlen
 
   SimpleLinkWaitEvent(HCI_CMND_CONNECT, &ret);
 
-  errno = ret;
-
+  set_errno(ret);
   return (long)ret;
 }
 
@@ -727,7 +722,7 @@ int cc3000_select_impl(long nfds, TICC3000fd_set *readsds, TICC3000fd_set *write
     }
   else
     {
-      errno = tParams.iStatus;
+      set_errno(tParams.iStatus);
       return -1;
     }
 }
@@ -813,7 +808,7 @@ int cc3000_setsockopt_impl(long sd, long level, long optname, const void *optval
     }
   else
     {
-      errno = ret;
+      set_errno(ret);
       return ret;
     }
 }
@@ -898,8 +893,8 @@ int cc3000_getsockopt_impl(long sd, long level, long optname, void *optval, sock
     }
   else
     {
-      errno = tRetParams.iStatus;
-      return errno;
+      set_errno(tRetParams.iStatus);
+      return tRetParams.iStatus;
     }
 }
 
@@ -961,8 +956,7 @@ int simple_link_recv(long sd, void *buf, long len, long flags, struct sockaddr *
       SimpleLinkWaitData((uint8_t *)buf, (uint8_t *)from, (uint8_t *)fromlen);
     }
 
-  errno = tSocketReadEvent.iNumberOfBytes;
-
+  set_errno(tSocketReadEvent.iNumberOfBytes);
   return tSocketReadEvent.iNumberOfBytes;
 }
 
diff --git a/nuttx/drivers/wireless/cc3000/wlan.c b/nuttx/drivers/wireless/cc3000/wlan.c
index f49a09add..5e680a697 100644
--- a/nuttx/drivers/wireless/cc3000/wlan.c
+++ b/nuttx/drivers/wireless/cc3000/wlan.c
@@ -396,7 +396,7 @@ long wlan_connect(unsigned long ulSecType, char *ssid, long ssid_len,
   /* Wait for command complete event */
 
   SimpleLinkWaitEvent(HCI_CMND_WLAN_CONNECT, &ret);
-  errno = ret;
+  set_errno(ret);
   cc3000_lib_unlock();
   return ret;
 }
@@ -436,7 +436,7 @@ long wlan_connect(char *ssid, long ssid_len)
   /* Wait for command complete event */
 
   SimpleLinkWaitEvent(HCI_CMND_WLAN_CONNECT, &ret);
-  errno = ret;
+  set_errno(ret);
 
   cc3000_lib_unlock();
 
@@ -473,7 +473,7 @@ long wlan_disconnect(void)
   /* Wait for command complete event */
 
   SimpleLinkWaitEvent(HCI_CMND_WLAN_DISCONNECT, &ret);
-  errno = ret;
+  set_errno(ret);
 
   cc3000_lib_unlock();
 
@@ -1055,7 +1055,6 @@ long wlan_smart_config_start(unsigned long algoEncryptedFlag)
   /* Fill in HCI packet structure */
 
   args = UINT32_TO_STREAM(args, algoEncryptedFlag);
-  ret  = EFAIL;
 
   hci_command_send(HCI_CMND_WLAN_IOCTL_SIMPLE_CONFIG_START, ptr,
                    WLAN_SMART_CONFIG_START_PARAMS_LEN);
diff --git a/nuttx/fs/fat/fs_fat32.c b/nuttx/fs/fat/fs_fat32.c
index c26d9ee61..a94352035 100644
--- a/nuttx/fs/fat/fs_fat32.c
+++ b/nuttx/fs/fat/fs_fat32.c
@@ -391,7 +391,7 @@ static int fat_close(FAR struct file *filep)
   struct inode         *inode;
   struct fat_file_s    *ff;
   struct fat_mountpt_s *fs;
-  int                   ret = OK;
+  int                   ret;
 
   /* Sanity checks */
 
@@ -1505,7 +1505,7 @@ static int fat_opendir(struct inode *mountpt, const char *relpath, struct fs_dir
 
 errout_with_semaphore:
   fat_semgive(fs);
-  return ERROR;
+  return ret;
 }
 
 /****************************************************************************
@@ -1523,7 +1523,7 @@ static int fat_readdir(struct inode *mountpt, struct fs_dirent_s *dir)
   uint8_t               ch;
   uint8_t               attribute;
   bool                  found;
-  int                   ret = OK;
+  int                   ret;
 
   /* Sanity checks */
 
diff --git a/nuttx/fs/nxffs/nxffs_open.c b/nuttx/fs/nxffs/nxffs_open.c
index 72fb6a9f9..ff7d5372f 100644
--- a/nuttx/fs/nxffs/nxffs_open.c
+++ b/nuttx/fs/nxffs/nxffs_open.c
@@ -1132,7 +1132,7 @@ int nxffs_close(FAR struct file *filep)
 {
   FAR struct nxffs_volume_s *volume;
   FAR struct nxffs_ofile_s *ofile;
-  int ret = -ENOSYS;
+  int ret;
 
   fvdbg("Closing\n");
 
diff --git a/nuttx/fs/romfs/fs_romfs.c b/nuttx/fs/romfs/fs_romfs.c
index 6a6fca355..e2999f364 100644
--- a/nuttx/fs/romfs/fs_romfs.c
+++ b/nuttx/fs/romfs/fs_romfs.c
@@ -745,7 +745,7 @@ static int romfs_opendir(FAR struct inode *mountpt, FAR const char *relpath,
 
 errout_with_semaphore:
   romfs_semgive(rm);
-  return ERROR;
+  return ret;
 }
 
 /****************************************************************************
diff --git a/nuttx/fs/smartfs/smartfs_procfs.c b/nuttx/fs/smartfs/smartfs_procfs.c
index 64f7101d4..f1c75c365 100644
--- a/nuttx/fs/smartfs/smartfs_procfs.c
+++ b/nuttx/fs/smartfs/smartfs_procfs.c
@@ -435,14 +435,11 @@ static int smartfs_rewinddir(struct fs_dirent_s *dir)
 
 static int smartfs_stat(const char *relpath, struct stat *buf)
 {
-  int ret = -ENOENT;
-
   /* TODO:  Decide if the relpath is valid and if it is a file
    *        or a directory and set it's permissions.
    */
 
   buf->st_mode = S_IFDIR|S_IROTH|S_IRGRP|S_IRUSR;
-  ret = OK;
 
   /* File/directory size, access block size */
 
@@ -450,7 +447,7 @@ static int smartfs_stat(const char *relpath, struct stat *buf)
   buf->st_blksize = 0;
   buf->st_blocks  = 0;
   
-  return ret;
+  return OK;
 }
 
 /****************************************************************************
diff --git a/nuttx/fs/smartfs/smartfs_smart.c b/nuttx/fs/smartfs/smartfs_smart.c
index 7264b3f64..50018a443 100644
--- a/nuttx/fs/smartfs/smartfs_smart.c
+++ b/nuttx/fs/smartfs/smartfs_smart.c
@@ -192,7 +192,7 @@ static int smartfs_open(FAR struct file *filep, const char *relpath,
   sf = (struct smartfs_ofile_s *) kmalloc(sizeof *sf);
   if (sf == NULL)
     {
-      ret = ENOMEM;
+      ret = -ENOMEM;
       goto errout_with_semaphore;
     }
 
@@ -213,7 +213,7 @@ static int smartfs_open(FAR struct file *filep, const char *relpath,
         {
           /* Can't open a dir as a file! */
 
-          ret = EISDIR;
+          ret = -EISDIR;
           goto errout_with_buffer;
         }
 
diff --git a/nuttx/fs/smartfs/smartfs_utils.c b/nuttx/fs/smartfs/smartfs_utils.c
index 30813a44b..3c41ce524 100644
--- a/nuttx/fs/smartfs/smartfs_utils.c
+++ b/nuttx/fs/smartfs/smartfs_utils.c
@@ -854,11 +854,10 @@ int smartfs_createentry(struct smartfs_mountpt_s *fs,
           goto errout;
         }
 
-      nextsector = ret;
+      nextsector = (uint16_t) ret;
 
       /* Set the newly allocated sector's type (file or dir) */
 
-      nextsector = (uint16_t) ret;
       if ((type & SMARTFS_DIRENT_TYPE) == SMARTFS_DIRENT_TYPE_DIR)
         {
           chainheader->type = SMARTFS_SECTOR_TYPE_DIR;
diff --git a/nuttx/graphics/nxbe/nxbe_getrectangle.c b/nuttx/graphics/nxbe/nxbe_getrectangle.c
index 547afb707..e0adce9bf 100644
--- a/nuttx/graphics/nxbe/nxbe_getrectangle.c
+++ b/nuttx/graphics/nxbe/nxbe_getrectangle.c
@@ -104,7 +104,7 @@ void nxbe_getrectangle(FAR struct nxbe_window_s *wnd,
   struct nxgl_rect_s remaining;
 
 #ifdef CONFIG_DEBUG
-  if (!wnd || !rect || ! rect || plane >= wnd->be->vinfo.nplanes)
+  if (!wnd || !rect || !dest || plane >= wnd->be->vinfo.nplanes)
     {
       gvdbg("Invalid parameters\n");
       return;
diff --git a/nuttx/graphics/nxconsole/nxcon_kbdin.c b/nuttx/graphics/nxconsole/nxcon_kbdin.c
index f4b116c46..c2633ebf0 100644
--- a/nuttx/graphics/nxconsole/nxcon_kbdin.c
+++ b/nuttx/graphics/nxconsole/nxcon_kbdin.c
@@ -272,7 +272,6 @@ int nxcon_poll(FAR struct file *filep, FAR struct pollfd *fds, bool setup)
   FAR struct inode *inode = filep->f_inode;
   FAR struct nxcon_state_s *priv;
   pollevent_t eventset;
-  int ndx;
   int ret;
   int i;
 
diff --git a/nuttx/graphics/nxconsole/nxcon_redraw.c b/nuttx/graphics/nxconsole/nxcon_redraw.c
index 05f0a47f8..b1363454c 100644
--- a/nuttx/graphics/nxconsole/nxcon_redraw.c
+++ b/nuttx/graphics/nxconsole/nxcon_redraw.c
@@ -148,5 +148,6 @@ void nxcon_redraw(NXCONSOLE handle, FAR const struct nxgl_rect_s *rect, bool mor
     {
       nxcon_fillchar(priv, rect, &priv->bm[i]);
     }
-  ret = nxcon_sempost(priv);
+
+  (void)nxcon_sempost(priv);
 }
diff --git a/nuttx/graphics/nxmu/nx_start.c b/nuttx/graphics/nxmu/nx_start.c
index 2996d6b65..0be859c81 100644
--- a/nuttx/graphics/nxmu/nx_start.c
+++ b/nuttx/graphics/nxmu/nx_start.c
@@ -148,7 +148,7 @@ int nx_server(int argc, char *argv[])
   /* Then start the server (nx_run does not normally return) */
 
   ret = nx_run(dev);
-  gvdbg("nx_run returned: %d\n", errno);
+  gvdbg("nx_run returned: %d\n", ret);
   return EXIT_FAILURE;
 }
 
diff --git a/nuttx/include/nuttx/input/touchscreen.h b/nuttx/include/nuttx/input/touchscreen.h
index f4dd2a691..d9e531d5f 100644
--- a/nuttx/include/nuttx/input/touchscreen.h
+++ b/nuttx/include/nuttx/input/touchscreen.h
@@ -128,7 +128,8 @@ struct touch_sample_s
 
 #ifdef __cplusplus
 #define EXTERN extern "C"
-extern "C" {
+extern "C"
+{
 #else
 #define EXTERN extern
 #endif
@@ -151,7 +152,7 @@ extern "C" {
  *
  ****************************************************************************/
 
-EXTERN int arch_tcinitialize(int minor);
+int arch_tcinitialize(int minor);
 
 /****************************************************************************
  * Name: arch_tcuninitialize
@@ -169,7 +170,7 @@ EXTERN int arch_tcinitialize(int minor);
  *
  ****************************************************************************/
 
-EXTERN void arch_tcuninitialize(void);
+void arch_tcuninitialize(void);
 
 #undef EXTERN
 #ifdef __cplusplus
diff --git a/nuttx/libc/audio/lib_buffer.c b/nuttx/libc/audio/lib_buffer.c
index 83fda877e..cf518de16 100644
--- a/nuttx/libc/audio/lib_buffer.c
+++ b/nuttx/libc/audio/lib_buffer.c
@@ -138,7 +138,7 @@ int apb_alloc(FAR struct audio_buf_desc_s *bufdesc)
     {
       /* Populate the buffer contents */
 
-      memset(pBuf, bufsize, 0);
+      memset(pBuf, 0, bufsize);
       pBuf->i.channels = 1;
       pBuf->crefs = 1;
       pBuf->nmaxbytes = bufdesc->numbytes;
diff --git a/nuttx/libc/time/lib_isleapyear.c b/nuttx/libc/time/lib_isleapyear.c
index 386e205b2..2a1a8664c 100644
--- a/nuttx/libc/time/lib_isleapyear.c
+++ b/nuttx/libc/time/lib_isleapyear.c
@@ -83,6 +83,6 @@
 
 int clock_isleapyear(int year)
 {
-  return year % 400 ? (year % 100 ? (year % 4 ? 0 : 1) : 0) : 1;
+  return (year % 400) ? ((year % 100) ? ((year % 4) ? 0 : 1) : 0) : 1;
 }
 
diff --git a/nuttx/net/bind.c b/nuttx/net/bind.c
index da912e017..cbb0a1dea 100644
--- a/nuttx/net/bind.c
+++ b/nuttx/net/bind.c
@@ -92,7 +92,7 @@ int psock_bind(FAR struct socket *psock, const struct sockaddr *addr,
 #endif
 
   int err;
-  int ret;
+  int ret = OK;
 
   /* Verify that the psock corresponds to valid, allocated socket */
 
diff --git a/nuttx/net/uip/uip_igmpgroup.c b/nuttx/net/uip/uip_igmpgroup.c
index 6e2b37f1d..29ba3bfe9 100644
--- a/nuttx/net/uip/uip_igmpgroup.c
+++ b/nuttx/net/uip/uip_igmpgroup.c
@@ -133,7 +133,7 @@ static FAR sq_queue_t g_freelist;
  ****************************************************************************/
 
 /****************************************************************************
- * Name:  uip_grpalloc
+ * Name:  uip_grpheapalloc
  *
  * Description:
  *   Allocate a new group from heap memory.
@@ -169,6 +169,7 @@ static inline FAR struct igmp_group_s *uip_grpprealloc(void)
       memset(group, 0, sizeof(struct igmp_group_s));
       group->flags = IGMP_PREALLOCATED;
     }
+
   return group;
 }
 #endif
@@ -237,9 +238,10 @@ FAR struct igmp_group_s *uip_grpalloc(FAR struct uip_driver_s *dev,
       grplldbg("Allocate from the heap\n");
       group = uip_grpheapalloc();
     }
+
   grplldbg("group: %p\n", group);
 
-  /* Check if we succesfully allocated a group structure */
+  /* Check if we successfully allocated a group structure */
 
   if (group)
     {
@@ -262,6 +264,7 @@ FAR struct igmp_group_s *uip_grpalloc(FAR struct uip_driver_s *dev,
       sq_addfirst((FAR sq_entry_t*)group, &dev->grplist);
       uip_unlock(flags);
     }
+
   return group;
 }
 
@@ -300,6 +303,7 @@ FAR struct igmp_group_s *uip_grpfind(FAR struct uip_driver_s *dev,
           break;
         }
     }
+
   uip_unlock(flags);
   return group;
 }
@@ -326,6 +330,7 @@ FAR struct igmp_group_s *uip_grpallocfind(FAR struct uip_driver_s *dev,
     {
       group = uip_grpalloc(dev, addr);
     }
+
   grplldbg("group: %p\n", group);
   return group;
 }
diff --git a/nuttx/net/uip/uip_igmpinit.c b/nuttx/net/uip/uip_igmpinit.c
index 740ddf44b..75de2846e 100644
--- a/nuttx/net/uip/uip_igmpinit.c
+++ b/nuttx/net/uip/uip_igmpinit.c
@@ -104,14 +104,12 @@ void uip_igmpinit(void)
 
 void uip_igmpdevinit(struct uip_driver_s *dev)
 {
-  struct igmp_group_s *group;
-
   nvdbg("IGMP initializing dev %p\n", dev);
   DEBUGASSERT(dev->grplist.head == NULL);
 
   /* Add the all systems address to the group */
 
-  group = uip_grpalloc(dev, &g_allsystems);
+  (void)uip_grpalloc(dev, &g_allsystems);
 
   /* Allow the IGMP messages at the MAC level */
 
diff --git a/nuttx/tools/bdf-converter.c b/nuttx/tools/bdf-converter.c
index a03faa93e..2c4efa1ec 100644
--- a/nuttx/tools/bdf-converter.c
+++ b/nuttx/tools/bdf-converter.c
@@ -33,12 +33,12 @@
  *
  ****************************************************************************/
 
-/* 
+/*
  * Based one the "Glyph Bitmap Distribution Format (BDF) Specification",
  * Version 2.2, by Adobe Systems Incorporated.
  *
  */
- 
+
 /****************************************************************************
  * Included Files
  ****************************************************************************/
@@ -58,7 +58,7 @@
 #define VERBOSE
 #define DBG
 */
- 
+
 // BDF Specification Version 2.2:
 // This version lifts the restriction on line length. In this version, the new
 // maximum length of a value of the type string is 65535 characters, and hence
@@ -126,6 +126,7 @@ typedef struct nx_fontmetric_s
  *   line  - The line to trim
  *
  ****************************************************************************/
+
 static void trimLine(char *line)
 {
   char *str;
@@ -157,15 +158,16 @@ static void trimLine(char *line)
  *                info[3] = -2
  *
  ****************************************************************************/
+
 static void bdf_parseintline(char *line, unsigned int count, int *info)
 {
   char *str, *token, *saveptr1;
   str = line;
-  
+
   /* Ignore the key */
-  
+
   token = (char *)strtok_r(str, " ", &saveptr1);
-  
+
   while ((token = (char *)strtok_r(NULL, " ", &saveptr1)) && count--)
     {
       *(info++) = atoi(token);
@@ -182,6 +184,7 @@ static void bdf_parseintline(char *line, unsigned int count, int *info)
  *   ginfo  - A glyphinfo_t struct with the glyph's information.
  *
  ****************************************************************************/
+
 #ifdef DBG
 static void bdf_printglyphinfo(const glyphinfo_t *ginfo)
 {
@@ -212,6 +215,7 @@ static void bdf_printglyphinfo(const glyphinfo_t *ginfo)
  *   info  - A nx_fontmetric_t struct with the glyph's information.
  *
  ****************************************************************************/
+
 #ifdef DBG
 static void bdf_printnxmetricinfo(const nx_fontmetric_t *info)
 {
@@ -240,49 +244,50 @@ static void bdf_printnxmetricinfo(const nx_fontmetric_t *info)
  *
  * Input Parameters:
  *   file  - The input file stream pointing to the first line of the
- *           glyph's information (right after STARTCHAR). 
+ *           glyph's information (right after STARTCHAR).
  *   ginfo - A glyphinfo_t struct to fill with the glyph's information.
  *
  ****************************************************************************/
+
 static void bdf_getglyphinfo(FILE *file, glyphinfo_t *ginfo)
 {
   char line[BDF_MAX_LINE_LENGTH];
   char lineCopy[BDF_MAX_LINE_LENGTH];
   char *str, *token, *saveptr1;
   bool done;
-  
+
   done = false;
-  
-  while(fgets(line, BDF_MAX_LINE_LENGTH, file) != NULL && !done)
+
+  while (fgets(line, BDF_MAX_LINE_LENGTH, file) != NULL && !done)
     {
       trimLine(line);
       strcpy(lineCopy, line);
       str = line;
-      
+
       while ((token = (char *)strtok_r(str, " ", &saveptr1)))
         {
 
           /* ENCODING information */
-          
-          if(strcmp(token, "ENCODING") == 0)
+
+          if (strcmp(token, "ENCODING") == 0)
             {
               token = (char *)strtok_r(NULL, " ", &saveptr1);
               ginfo->encoding = atoi(token);
             }
-            
+
           /* DWIDTH information */
-          
-          if(strcmp(token, "DWIDTH") == 0)
+
+          if (strcmp(token, "DWIDTH") == 0)
             {
               token = (char *)strtok_r(NULL, " ", &saveptr1);
               ginfo->dw_x0 = atoi(token);
               token = (char *)strtok_r(NULL, " ", &saveptr1);
               ginfo->dw_y0 = atoi(token);
             }
-            
+
           /* BBX information */
-          
-          else if(strcmp(token, "BBX") == 0)
+
+          else if (strcmp(token, "BBX") == 0)
             {
               int bbxinfo[4];
               bdf_parseintline(lineCopy, 4, bbxinfo);
@@ -290,15 +295,14 @@ static void bdf_getglyphinfo(FILE *file, glyphinfo_t *ginfo)
               ginfo->bb_h     = bbxinfo[1];
               ginfo->bb_x_off = bbxinfo[2];
               ginfo->bb_y_off = bbxinfo[3];
-              
+
               /* This is the last BDF property of interest*/
-              
+
               done = true;
             }
 
           str = NULL;
         }
-      
     }
 }
 
@@ -310,44 +314,43 @@ static void bdf_getglyphinfo(FILE *file, glyphinfo_t *ginfo)
  *
  * Input Parameters:
  *   file  - The input file stream pointing to the first line of the
- *           glyph's bitmap (right after BITMAP). 
+ *           glyph's bitmap (right after BITMAP).
  *   ginfo - A glyphinfo_t struct to fill with the glyph's bitmap.
  *
  ****************************************************************************/
+
 static void bdf_getglyphbitmap(FILE *file, glyphinfo_t *ginfo)
 {
   char line[BDF_MAX_LINE_LENGTH];
   uint64_t *bitmap;
   bool readingbitmap;
-  
+
   bitmap = ginfo->bitmap;
   readingbitmap = true;
-  
+
   while (readingbitmap)
     {
       if (fgets(line, BDF_MAX_LINE_LENGTH, file) != NULL)
-      {
-        trimLine(line);
-      
-        if(strcmp(line, "ENDCHAR") == 0)
-          {
-            readingbitmap = false;
-          }
-        else
-          {
-            char *endptr;
-            *bitmap = strtoul(line, &endptr, 16);
-            bitmap++;
-          }
-          
-      }
+        {
+          trimLine(line);
+
+          if (strcmp(line, "ENDCHAR") == 0)
+            {
+              readingbitmap = false;
+            }
+          else
+            {
+              char *endptr;
+              *bitmap = strtoul(line, &endptr, 16);
+              bitmap++;
+            }
+        }
       else
-      {
-        /* error condition */
-        
-        readingbitmap = false;
-      }
-       
+        {
+          /* error condition */
+
+          readingbitmap = false;
+        }
     }
 }
 
@@ -382,21 +385,20 @@ static void bdf_getstride(glyphinfo_t *ginfo, uint32_t *stride)
  *   nxmetric  - A nx_fontmetric_t struct with the glyph's information.
  *
  ****************************************************************************/
-static void bdf_printoutput(FILE *out, 
+static void bdf_printoutput(FILE *out,
                             glyphinfo_t *ginfo,
                             nx_fontmetric_t *nxmetric)
 {
 
   /* Only interested in the 7 and 8 bit ranges */
-  
+
   if ((ginfo->encoding >= NXFONT_MIN7BIT  &&
        ginfo->encoding <= NXFONT_MAX7BIT) ||
       (ginfo->encoding >= NXFONT_MIN8BIT  &&
        ginfo->encoding <= NXFONT_MAX8BIT))
     {
-      
       /* Glyph general info */
-      
+
       if (ginfo->bb_x_off < 0)
         {
           fprintf(out,
@@ -409,9 +411,9 @@ static void bdf_printoutput(FILE *out,
         {
           fprintf(out, "/* %s (%d) */\n", ginfo->name, ginfo->encoding);
         }
-      
+
       /* Glyph metrics */
-      
+
       fprintf(out,
               "#define NXFONT_METRICS_%d {%d, %d, %d, %d, %d, 0}\n",
               ginfo->encoding,
@@ -420,9 +422,9 @@ static void bdf_printoutput(FILE *out,
               nxmetric->height,
               nxmetric->xoffset,
               nxmetric->yoffset);
-              
+
       /* Glyph bitmap */
-      
+
       fprintf(out, "#define NXFONT_BITMAP_%d {", ginfo->encoding);
       int i, j;
       for (i = 0; i < ginfo->bb_h - 1; i++)
@@ -432,28 +434,28 @@ static void bdf_printoutput(FILE *out,
               int nxbyteoffset;
               uint8_t  nxbyte = 0;
               uint64_t tempbitmap = ginfo->bitmap[i];
-              
+
               /* Get the next byte */
-              
+
               nxbyteoffset = (nxmetric->stride - j) * 8;
               nxbyte = (uint8_t)(tempbitmap >> nxbyteoffset);
               fprintf(out, "0x%x, ", nxbyte);
             }
         }
-      
+
       /* Different behavior for the last bitmap */
-      
+
       for (j = 1; j <= nxmetric->stride; j++)
         {
           int nxbyteoffset;
           uint8_t  nxbyte = 0;
           uint64_t tempbitmap = ginfo->bitmap[i];
-          
+
           /* Get the next byte */
-          
+
           nxbyteoffset = (nxmetric->stride - j) * 8;
           nxbyte = (uint8_t)(tempbitmap >> nxbyteoffset);
-          
+
           if (j == nxmetric->stride)
             {
               fprintf(out, "0x%x}\n", nxbyte);
@@ -462,11 +464,10 @@ static void bdf_printoutput(FILE *out,
             {
               fprintf(out, "0x%x, ", nxbyte);
             }
-        }      
-      
+        }
+
       fprintf(out, "\n");
     }
-
 }
 
 /****************************************************************************
@@ -480,26 +481,26 @@ int main(int argc, char **argv)
   char lineCopy[BDF_MAX_LINE_LENGTH];
   char *str, *token, *saveptr1;
   char *input, *output;
-  
+
   /* FONTBOUNDINGBOX properties*/
-  
+
   int fbb_x     = 0;
   int fbb_y     = 0;
-  int fbb_x_off = 0;
+//int fbb_x_off = 0;
   int fbb_y_off = 0;
-  
+
   /* Input BDF file */
-  
+
   input = argv[1];
-  
+
   if (input == NULL)
     {
       printf("%s: no input file\n", argv[0]);
       exit(0);
     }
-    
+
   file = fopen(input, "r");
-  
+
   if (file == NULL)
     {
       printf("%s: error opening file %s\n", argv[0], input);
@@ -511,8 +512,9 @@ int main(int argc, char **argv)
       printf("Opening \"%s\"\n", input);
 #endif /* VERBOSE */
     }
-  
+
   /* Output file */
+
   if (argv[2])
     {
       output = argv[2];
@@ -521,9 +523,9 @@ int main(int argc, char **argv)
     {
       output = "nxfonts_myfont.h";
     }
-  
+
   out  = fopen(output, "w");
-  
+
   if (out == NULL)
     {
       printf("%s: error opening file %s\n", argv[0], output);
@@ -534,61 +536,62 @@ int main(int argc, char **argv)
     {
       while (fgets(line, BDF_MAX_LINE_LENGTH, file) != NULL)
         {
-        
+
 #ifdef DBG
           printf("--\n");
 #endif /* DBG */
-          
+
           // Save a copy of the line
-          
+
           strcpy(lineCopy,line);
-          
+
           // Clean it
-          
+
           trimLine(line);
           str = line;
 
           while ((token = (char *)strtok_r(str, " ", &saveptr1)))
             {
-            
+
               /* FONTBOUNDINGBOX - Global font information */
-            
+
               if (strcmp(token, "FONTBOUNDINGBOX") == 0)
                 {
                   int fbbinfo[4];
                   bdf_parseintline(lineCopy, 4, fbbinfo);
                   fbb_x     = fbbinfo[0];
                   fbb_y     = fbbinfo[1];
-                  fbb_x_off = fbbinfo[2];
+                //fbb_x_off = fbbinfo[2];
                   fbb_y_off = fbbinfo[3];
-                  
+
                   /* Print FONTBOUNDINGBOX information */
-                  
+
                   fprintf(out, "/* Maximum height and width of any");
                   fprintf(out, " glyph in the set */\n\n");
                   fprintf(out, "#define NXFONT_MAXHEIGHT  %d\n", fbb_y);
                   fprintf(out, "#define NXFONT_MAXWIDTH   %d\n\n", fbb_x);
                 }
-                
+
               /* STARTCHAR - Individual glyph information */
-                
+
               if (strcmp(token, "STARTCHAR") == 0)
                 {
                   glyphinfo_t ginfo;
-                  
+
                   /* Glyph name */
-                  
+
                   ginfo.name = (char *)strtok_r(NULL, " ", &saveptr1);
 
 #ifdef VERBOSE
                   printf("Processing glyph: %s\n", ginfo.name);
 #endif /* VERBOSE */
-                  
+
                   /* Glyph information:
                   *    ENCODING
                   *    DWIDTH
                   *    BBX
                   */
+
                   ginfo.encoding = 0;
                   ginfo.dw_x0    = 0;
                   ginfo.dw_y0    = 0;
@@ -597,18 +600,18 @@ int main(int argc, char **argv)
                   ginfo.bb_x_off = 0;
                   ginfo.bb_y_off = 0;
                   bdf_getglyphinfo(file, &ginfo);
-                  
+
                   /* Glyph bitmap */
-                  
+
                   ginfo.bitmap = malloc(sizeof(uint64_t) * ginfo.bb_h);
                   bdf_getglyphbitmap(file, &ginfo);
-                  
+
 #ifdef DBG
                   bdf_printglyphinfo(&ginfo);
 #endif /* DBG */
-                  
+
                   /* Convert to nxfonts */
-                  
+
                   nx_fontmetric_t nxmetric;
                   uint32_t stride;
                   bdf_getstride(&ginfo, &stride);
@@ -618,7 +621,7 @@ int main(int argc, char **argv)
 
                   /* The NuttX font format does not support
                    * negative X offsets. */
-                  
+
                   if (ginfo.bb_x_off < 0)
                     {
                       nxmetric.xoffset = 0;
@@ -632,12 +635,11 @@ int main(int argc, char **argv)
                     {
                       nxmetric.xoffset = ginfo.bb_x_off;
                     }
-                    
+
                   nxmetric.yoffset = fbb_y + fbb_y_off -
                                      ginfo.bb_y_off - ginfo.bb_h;
-                                     
-                  
-#ifdef DBG                  
+
+#ifdef DBG
                   bdf_printnxmetricinfo(&nxmetric);
 #endif /* DBG */
 
@@ -652,25 +654,26 @@ int main(int argc, char **argv)
                     {
                       bdf_printoutput(out, &ginfo, &nxmetric);
                     }
-                  
+
                   /* Free memory */
-                  
+
                   free(ginfo.bitmap);
-                  
+
                 }
-              
+
               str = NULL;
             }
-          
+
         }
+
       fclose(file);
       fclose(out);
-      
+
       /* The End */
-      
+
       printf("Generated \"%s\"\n", output);
-      
+
     }
-    
+
   return EXIT_SUCCESS;
 }
diff --git a/nuttx/tools/configure.c b/nuttx/tools/configure.c
index 1bb68147a..323177b75 100644
--- a/nuttx/tools/configure.c
+++ b/nuttx/tools/configure.c
@@ -200,7 +200,7 @@ static void parse_args(int argc, char **argv)
             fprintf(stderr, "ERROR: Missing option argument, option: %c\n", optopt);
             show_usage(argv[0], EXIT_FAILURE);
 
-           break;
+          default:
             fprintf(stderr, "ERROR: Unexpected option: %c\n", ch);
             show_usage(argv[0], EXIT_FAILURE);
         }
diff --git a/nuttx/tools/kconfig2html.c b/nuttx/tools/kconfig2html.c
index b7deacf1f..a09fb67b6 100644
--- a/nuttx/tools/kconfig2html.c
+++ b/nuttx/tools/kconfig2html.c
@@ -2101,7 +2101,6 @@ static inline char *process_menu(FILE *stream, const char *kconfigdir)
   const char *paranum;
   char *menuname;
   char *token = NULL;
-  char *ptr;
 
   /* Get the menu information */
 
@@ -2114,7 +2113,7 @@ static inline char *process_menu(FILE *stream, const char *kconfigdir)
 
   /* Process each line in the choice */
 
-  while ((ptr = kconfig_line(stream)) != NULL)
+  while (kconfig_line(stream) != NULL)
     {
       /* Process the first token on the Kconfig file line */
 
@@ -2228,11 +2227,10 @@ static char *parse_kconfigfile(FILE *stream, const char *kconfigdir)
 {
   enum token_type_e tokid;
   char *token = NULL;
-  char *ptr;
 
   /* Process each line in the Kconfig file */
 
-  while ((ptr = kconfig_line(stream)) != NULL)
+  while (kconfig_line(stream) != NULL)
     {
       /* Process the first token on the Kconfig file line */
 
@@ -2475,7 +2473,7 @@ int main(int argc, char **argv, char **envp)
             error("Missing option argument, option: %c\n", optopt);
             show_usage(argv[0], ERROR_MISSING_OPTION_ARGUMENT);
 
-           break;
+          default:
             error("Unexpected option: %c\n", ch);
             show_usage(argv[0], ERROR_UNEXPECTED_OPTION);
         }
diff --git a/nuttx/tools/mkdeps.c b/nuttx/tools/mkdeps.c
index 646f0e3ad..003b1234b 100644
--- a/nuttx/tools/mkdeps.c
+++ b/nuttx/tools/mkdeps.c
@@ -635,8 +635,6 @@ static char *cywin2windows(const char *str, const char *append, enum slashmode_e
 
   if (append)
     {
-      char *tmp;
-
       alloclen = sizeof(str) + sizeof(append) + 1;
       allocpath = (char *)malloc(alloclen);
       if (!allocpath)
diff --git a/nuttx/tools/mksymtab.c b/nuttx/tools/mksymtab.c
index e401812c0..5074c2940 100644
--- a/nuttx/tools/mksymtab.c
+++ b/nuttx/tools/mksymtab.c
@@ -148,7 +148,7 @@ int main(int argc, char **argv, char **envp)
             fprintf(stderr, "Missing option argument, option: %c\n", optopt);
             show_usage(argv[0]);
 
-           break;
+          default:
             fprintf(stderr, "Unexpected option: %c\n", ch);
             show_usage(argv[0]);
         }
diff --git a/nuttx/tools/mksyscall.c b/nuttx/tools/mksyscall.c
index c5e15a87b..8bcfcf1ee 100644
--- a/nuttx/tools/mksyscall.c
+++ b/nuttx/tools/mksyscall.c
@@ -606,7 +606,7 @@ int main(int argc, char **argv, char **envp)
             fprintf(stderr, "Missing option argument, option: %c\n", optopt);
             show_usage(argv[0]);
 
-           break;
+          default:
             fprintf(stderr, "Unexpected option: %c\n", ch);
             show_usage(argv[0]);
         }