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

22 files changed, 1481 insertions, 1178 deletions

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);