Remove up_assert_code

11 files changed, 207 insertions, 248 deletions

diff --git a/nuttx/arch/avr/src/at32uc3/at32uc3_irq.c b/nuttx/arch/avr/src/at32uc3/at32uc3_irq.c
index 771d1b9da..70ade3e2a 100644
--- a/nuttx/arch/avr/src/at32uc3/at32uc3_irq.c
+++ b/nuttx/arch/avr/src/at32uc3/at32uc3_irq.c
@@ -179,7 +179,7 @@ static int avr32_xcptn(int irq, FAR void *context)
 {
   (void)irqsave();
   lldbg("PANIC!!! Exception IRQ: %d\n", irq);
-  PANIC(OSERR_UNEXPECTEDISR);
+  PANIC();
   return 0;
 }
 
diff --git a/nuttx/arch/avr/src/at32uc3/at32uc3_serial.c b/nuttx/arch/avr/src/at32uc3/at32uc3_serial.c
index f33ce7d72..1ddb9901b 100644
--- a/nuttx/arch/avr/src/at32uc3/at32uc3_serial.c
+++ b/nuttx/arch/avr/src/at32uc3/at32uc3_serial.c
@@ -468,7 +468,7 @@ static int up_interrupt(int irq, void *context)
   else
 #endif
     {
-      PANIC(OSERR_INTERNAL);
+      PANIC();
     }
   priv = (struct up_dev_s*)dev->priv;
   DEBUGASSERT(priv);
diff --git a/nuttx/arch/avr/src/avr/up_blocktask.c b/nuttx/arch/avr/src/avr/up_blocktask.c
index 7d48da78a..82fcd65db 100644
--- a/nuttx/arch/avr/src/avr/up_blocktask.c
+++ b/nuttx/arch/avr/src/avr/up_blocktask.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/avr/src/avr/up_blocktask.c
  *
- *   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011, 2013 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -86,82 +86,77 @@
 
 void up_block_task(struct tcb_s *tcb, tstate_t task_state)
 {
-  /* Verify that the context switch can be performed */
-
-  if ((tcb->task_state < FIRST_READY_TO_RUN_STATE) ||
-      (tcb->task_state > LAST_READY_TO_RUN_STATE))
-    {
-      PANIC(OSERR_BADBLOCKSTATE);
-    }
-  else
-    {
-      struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head;
-      bool switch_needed;
+  struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head;
+  bool switch_needed;
 
-      /* Remove the tcb task from the ready-to-run list.  If we
-       * are blocking the task at the head of the task list (the
-       * most likely case), then a context switch to the next
-       * ready-to-run task is needed. In this case, it should
-       * also be true that rtcb == tcb.
-       */
+  /* Verify that the context switch can be performed */
 
-      switch_needed = sched_removereadytorun(tcb);
+  ASSERT((tcb->task_state >= FIRST_READY_TO_RUN_STATE) &&
+         (tcb->task_state <= LAST_READY_TO_RUN_STATE));
 
-      /* Add the task to the specified blocked task list */
+  /* Remove the tcb task from the ready-to-run list.  If we
+   * are blocking the task at the head of the task list (the
+   * most likely case), then a context switch to the next
+   * ready-to-run task is needed. In this case, it should
+   * also be true that rtcb == tcb.
+   */
 
-      sched_addblocked(tcb, (tstate_t)task_state);
+  switch_needed = sched_removereadytorun(tcb);
 
-      /* If there are any pending tasks, then add them to the g_readytorun
-       * task list now
-       */
+  /* Add the task to the specified blocked task list */
 
-      if (g_pendingtasks.head)
-        {
-          switch_needed |= sched_mergepending();
-        }
+  sched_addblocked(tcb, (tstate_t)task_state);
 
-      /* Now, perform the context switch if one is needed */
+  /* If there are any pending tasks, then add them to the g_readytorun
+   * task list now
+   */
 
-      if (switch_needed)
-        {
-          /* Are we in an interrupt handler? */
+  if (g_pendingtasks.head)
+    {
+      switch_needed |= sched_mergepending();
+    }
 
-          if (current_regs)
-            {
-              /* Yes, then we have to do things differently.
-               * Just copy the current_regs into the OLD rtcb.
-               */
+  /* Now, perform the context switch if one is needed */
 
-               up_savestate(rtcb->xcp.regs);
+  if (switch_needed)
+    {
+      /* Are we in an interrupt handler? */
 
-              /* Restore the exception context of the rtcb at the (new) head 
-               * of the g_readytorun task list.
-               */
+      if (current_regs)
+        {
+          /* Yes, then we have to do things differently.
+           * Just copy the current_regs into the OLD rtcb.
+           */
 
-              rtcb = (struct tcb_s*)g_readytorun.head;
+          up_savestate(rtcb->xcp.regs);
 
-              /* Then switch contexts */
+          /* Restore the exception context of the rtcb at the (new) head 
+           * of the g_readytorun task list.
+           */
 
-              up_restorestate(rtcb->xcp.regs);
-            }
+          rtcb = (struct tcb_s*)g_readytorun.head;
 
-          /* No, then we will need to perform the user context switch */
+          /* Then switch contexts */
 
-          else
-            {
-              /* Switch context to the context of the task at the head of the
-               * ready to run list.
-               */
+          up_restorestate(rtcb->xcp.regs);
+        }
 
-               struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head;
-               up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
+      /* No, then we will need to perform the user context switch */
 
-              /* up_switchcontext forces a context switch to the task at the
-               * head of the ready-to-run list.  It does not 'return' in the
-               * normal sense.  When it does return, it is because the blocked
-               * task is again ready to run and has execution priority.
-               */
-           }
+      else
+        {
+          /* Switch context to the context of the task at the head of the
+           * ready to run list.
+           */
+
+          struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head;
+          up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
+
+          /* up_switchcontext forces a context switch to the task at the
+           * head of the ready-to-run list.  It does not 'return' in the
+           * normal sense.  When it does return, it is because the blocked
+           * task is again ready to run and has execution priority.
+           */
         }
     }
 }
diff --git a/nuttx/arch/avr/src/avr/up_doirq.c b/nuttx/arch/avr/src/avr/up_doirq.c
index 7533d2159..4db08c046 100644
--- a/nuttx/arch/avr/src/avr/up_doirq.c
+++ b/nuttx/arch/avr/src/avr/up_doirq.c
@@ -74,7 +74,7 @@ uint8_t *up_doirq(uint8_t irq, uint8_t *regs)
 {
   up_ledon(LED_INIRQ);
 #ifdef CONFIG_SUPPRESS_INTERRUPTS
-  PANIC(OSERR_ERREXCEPTION);
+  PANIC();
 #else
   uint8_t *savestate;
 
diff --git a/nuttx/arch/avr/src/avr/up_reprioritizertr.c b/nuttx/arch/avr/src/avr/up_reprioritizertr.c
index 5b23a37a1..4c510f4ea 100644
--- a/nuttx/arch/avr/src/avr/up_reprioritizertr.c
+++ b/nuttx/arch/avr/src/avr/up_reprioritizertr.c
@@ -98,7 +98,7 @@ void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority)
 #endif
     )
     {
-       PANIC(OSERR_BADREPRIORITIZESTATE);
+       PANIC();
     }
   else
     {
diff --git a/nuttx/arch/avr/src/avr/up_unblocktask.c b/nuttx/arch/avr/src/avr/up_unblocktask.c
index f1707b7bd..970deedd6 100644
--- a/nuttx/arch/avr/src/avr/up_unblocktask.c
+++ b/nuttx/arch/avr/src/avr/up_unblocktask.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  *  arch/avr/src/avr/up_unblocktask.c
  *
- *   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011, 2013 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -81,77 +81,72 @@
 
 void up_unblock_task(struct tcb_s *tcb)
 {
+  struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head;
+
   /* Verify that the context switch can be performed */
 
-  if ((tcb->task_state < FIRST_BLOCKED_STATE) ||
-      (tcb->task_state > LAST_BLOCKED_STATE))
-    {
-      PANIC(OSERR_BADUNBLOCKSTATE);
-    }
-  else
-    {
-      struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head;
+  ASSERT((tcb->task_state >= FIRST_BLOCKED_STATE) &&
+         (tcb->task_state <= LAST_BLOCKED_STATE));
 
-      /* Remove the task from the blocked task list */
+  /* Remove the task from the blocked task list */
 
-      sched_removeblocked(tcb);
+  sched_removeblocked(tcb);
 
-      /* Reset its timeslice.  This is only meaningful for round
-       * robin tasks but it doesn't here to do it for everything
-       */
+  /* Reset its timeslice.  This is only meaningful for round
+   * robin tasks but it doesn't here to do it for everything
+   */
 
 #if CONFIG_RR_INTERVAL > 0
-      tcb->timeslice = CONFIG_RR_INTERVAL / MSEC_PER_TICK;
+  tcb->timeslice = CONFIG_RR_INTERVAL / MSEC_PER_TICK;
 #endif
 
-      /* Add the task in the correct location in the prioritized
-       * g_readytorun task list
+  /* Add the task in the correct location in the prioritized
+   * g_readytorun task list
+   */
+
+  if (sched_addreadytorun(tcb))
+    {
+      /* The currently active task has changed! We need to do
+       * a context switch to the new task.
+       *
+       * Are we in an interrupt handler? 
        */
 
-      if (sched_addreadytorun(tcb))
+      if (current_regs)
         {
-          /* The currently active task has changed! We need to do
-           * a context switch to the new task.
-           *
-           * Are we in an interrupt handler? 
+          /* Yes, then we have to do things differently.
+           * Just copy the current_regs into the OLD rtcb.
            */
 
-          if (current_regs)
-            {
-              /* Yes, then we have to do things differently.
-               * Just copy the current_regs into the OLD rtcb.
-               */
+          up_savestate(rtcb->xcp.regs);
 
-               up_savestate(rtcb->xcp.regs);
-
-              /* Restore the exception context of the rtcb at the (new) head 
-               * of the g_readytorun task list.
-               */
+          /* Restore the exception context of the rtcb at the (new) head 
+           * of the g_readytorun task list.
+           */
 
-              rtcb = (struct tcb_s*)g_readytorun.head;
+          rtcb = (struct tcb_s*)g_readytorun.head;
 
-              /* Then switch contexts */
+          /* Then switch contexts */
 
-              up_restorestate(rtcb->xcp.regs);
-            }
+          up_restorestate(rtcb->xcp.regs);
+        }
 
-          /* No, then we will need to perform the user context switch */
+      /* No, then we will need to perform the user context switch */
 
-          else
-            {
-              /* Switch context to the context of the task at the head of the
-               * ready to run list.
-               */
+      else
+        {
+          /* Switch context to the context of the task at the head of the
+           * ready to run list.
+           */
 
-               struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head;
-               up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
+          struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head;
+          up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
 
-              /* up_switchcontext forces a context switch to the task at the
-               * head of the ready-to-run list.  It does not 'return' in the
-               * normal sense.  When it does return, it is because the blocked
-               * task is again ready to run and has execution priority.
-               */
-           }
+          /* up_switchcontext forces a context switch to the task at the
+           * head of the ready-to-run list.  It does not 'return' in the
+           * normal sense.  When it does return, it is because the blocked
+           * task is again ready to run and has execution priority.
+           */
         }
     }
 }
diff --git a/nuttx/arch/avr/src/avr32/up_blocktask.c b/nuttx/arch/avr/src/avr32/up_blocktask.c
index a5ff53ae9..1da4eb573 100644
--- a/nuttx/arch/avr/src/avr32/up_blocktask.c
+++ b/nuttx/arch/avr/src/avr32/up_blocktask.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/avr/src/avr32/up_blocktask.c
  *
- *   Copyright (C) 2010 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2010, 2013 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -86,82 +86,77 @@
 
 void up_block_task(struct tcb_s *tcb, tstate_t task_state)
 {
-  /* Verify that the context switch can be performed */
-
-  if ((tcb->task_state < FIRST_READY_TO_RUN_STATE) ||
-      (tcb->task_state > LAST_READY_TO_RUN_STATE))
-    {
-      PANIC(OSERR_BADBLOCKSTATE);
-    }
-  else
-    {
-      struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head;
-      bool switch_needed;
+  struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head;
+  bool switch_needed;
 
-      /* Remove the tcb task from the ready-to-run list.  If we
-       * are blocking the task at the head of the task list (the
-       * most likely case), then a context switch to the next
-       * ready-to-run task is needed. In this case, it should
-       * also be true that rtcb == tcb.
-       */
+  /* Verify that the context switch can be performed */
 
-      switch_needed = sched_removereadytorun(tcb);
+  ASSERT((tcb->task_state >= FIRST_READY_TO_RUN_STATE) &&
+         (tcb->task_state <= LAST_READY_TO_RUN_STATE));
 
-      /* Add the task to the specified blocked task list */
+  /* Remove the tcb task from the ready-to-run list.  If we
+   * are blocking the task at the head of the task list (the
+   * most likely case), then a context switch to the next
+   * ready-to-run task is needed. In this case, it should
+   * also be true that rtcb == tcb.
+   */
 
-      sched_addblocked(tcb, (tstate_t)task_state);
+  switch_needed = sched_removereadytorun(tcb);
 
-      /* If there are any pending tasks, then add them to the g_readytorun
-       * task list now
-       */
+  /* Add the task to the specified blocked task list */
 
-      if (g_pendingtasks.head)
-        {
-          switch_needed |= sched_mergepending();
-        }
+  sched_addblocked(tcb, (tstate_t)task_state);
 
-      /* Now, perform the context switch if one is needed */
+  /* If there are any pending tasks, then add them to the g_readytorun
+   * task list now
+   */
 
-      if (switch_needed)
-        {
-          /* Are we in an interrupt handler? */
+  if (g_pendingtasks.head)
+    {
+      switch_needed |= sched_mergepending();
+    }
 
-          if (current_regs)
-            {
-              /* Yes, then we have to do things differently.
-               * Just copy the current_regs into the OLD rtcb.
-               */
+  /* Now, perform the context switch if one is needed */
 
-               up_savestate(rtcb->xcp.regs);
+  if (switch_needed)
+    {
+      /* Are we in an interrupt handler? */
 
-              /* Restore the exception context of the rtcb at the (new) head 
-               * of the g_readytorun task list.
-               */
+      if (current_regs)
+        {
+          /* Yes, then we have to do things differently.
+           * Just copy the current_regs into the OLD rtcb.
+           */
 
-              rtcb = (struct tcb_s*)g_readytorun.head;
+          up_savestate(rtcb->xcp.regs);
 
-              /* Then switch contexts */
+          /* Restore the exception context of the rtcb at the (new) head 
+           * of the g_readytorun task list.
+           */
 
-              up_restorestate(rtcb->xcp.regs);
-            }
+          rtcb = (struct tcb_s*)g_readytorun.head;
 
-          /* No, then we will need to perform the user context switch */
+          /* Then switch contexts */
 
-          else
-            {
-              /* Switch context to the context of the task at the head of the
-               * ready to run list.
-               */
+          up_restorestate(rtcb->xcp.regs);
+        }
 
-               struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head;
-               up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
+      /* No, then we will need to perform the user context switch */
 
-              /* up_switchcontext forces a context switch to the task at the
-               * head of the ready-to-run list.  It does not 'return' in the
-               * normal sense.  When it does return, it is because the blocked
-               * task is again ready to run and has execution priority.
-               */
-           }
+      else
+        {
+          /* Switch context to the context of the task at the head of the
+           * ready to run list.
+           */
+
+          struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head;
+          up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
+
+          /* up_switchcontext forces a context switch to the task at the
+           * head of the ready-to-run list.  It does not 'return' in the
+           * normal sense.  When it does return, it is because the blocked
+           * task is again ready to run and has execution priority.
+           */
         }
     }
 }
diff --git a/nuttx/arch/avr/src/avr32/up_doirq.c b/nuttx/arch/avr/src/avr32/up_doirq.c
index 2d4a5e14a..c4513e77f 100644
--- a/nuttx/arch/avr/src/avr32/up_doirq.c
+++ b/nuttx/arch/avr/src/avr32/up_doirq.c
@@ -74,7 +74,7 @@ uint32_t *up_doirq(int irq, uint32_t *regs)
 {
   up_ledon(LED_INIRQ);
 #ifdef CONFIG_SUPPRESS_INTERRUPTS
-  PANIC(OSERR_ERREXCEPTION);
+  PANIC();
 #else
   uint32_t *savestate;
 
diff --git a/nuttx/arch/avr/src/avr32/up_reprioritizertr.c b/nuttx/arch/avr/src/avr32/up_reprioritizertr.c
index bc9ba21f0..621f08613 100644
--- a/nuttx/arch/avr/src/avr32/up_reprioritizertr.c
+++ b/nuttx/arch/avr/src/avr32/up_reprioritizertr.c
@@ -98,7 +98,7 @@ void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority)
 #endif
     )
     {
-       PANIC(OSERR_BADREPRIORITIZESTATE);
+       PANIC();
     }
   else
     {
diff --git a/nuttx/arch/avr/src/avr32/up_unblocktask.c b/nuttx/arch/avr/src/avr32/up_unblocktask.c
index 5ce48e366..1fcfa1dd7 100644
--- a/nuttx/arch/avr/src/avr32/up_unblocktask.c
+++ b/nuttx/arch/avr/src/avr32/up_unblocktask.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  *  arch/avr/src/avr32/up_unblocktask.c
  *
- *   Copyright (C) 2010 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2010, 2013 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -81,77 +81,72 @@
 
 void up_unblock_task(struct tcb_s *tcb)
 {
+  struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head;
+
   /* Verify that the context switch can be performed */
 
-  if ((tcb->task_state < FIRST_BLOCKED_STATE) ||
-      (tcb->task_state > LAST_BLOCKED_STATE))
-    {
-      PANIC(OSERR_BADUNBLOCKSTATE);
-    }
-  else
-    {
-      struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head;
+  ASSERT((tcb->task_state >= FIRST_BLOCKED_STATE) &&
+         (tcb->task_state <= LAST_BLOCKED_STATE));
 
-      /* Remove the task from the blocked task list */
+  /* Remove the task from the blocked task list */
 
-      sched_removeblocked(tcb);
+  sched_removeblocked(tcb);
 
-      /* Reset its timeslice.  This is only meaningful for round
-       * robin tasks but it doesn't here to do it for everything
-       */
+  /* Reset its timeslice.  This is only meaningful for round
+   * robin tasks but it doesn't here to do it for everything
+   */
 
 #if CONFIG_RR_INTERVAL > 0
-      tcb->timeslice = CONFIG_RR_INTERVAL / MSEC_PER_TICK;
+  tcb->timeslice = CONFIG_RR_INTERVAL / MSEC_PER_TICK;
 #endif
 
-      /* Add the task in the correct location in the prioritized
-       * g_readytorun task list
+  /* Add the task in the correct location in the prioritized
+   * g_readytorun task list
+   */
+
+  if (sched_addreadytorun(tcb))
+    {
+      /* The currently active task has changed! We need to do
+       * a context switch to the new task.
+       *
+       * Are we in an interrupt handler? 
        */
 
-      if (sched_addreadytorun(tcb))
+      if (current_regs)
         {
-          /* The currently active task has changed! We need to do
-           * a context switch to the new task.
-           *
-           * Are we in an interrupt handler? 
+          /* Yes, then we have to do things differently.
+           * Just copy the current_regs into the OLD rtcb.
            */
 
-          if (current_regs)
-            {
-              /* Yes, then we have to do things differently.
-               * Just copy the current_regs into the OLD rtcb.
-               */
+          up_savestate(rtcb->xcp.regs);
 
-               up_savestate(rtcb->xcp.regs);
-
-              /* Restore the exception context of the rtcb at the (new) head 
-               * of the g_readytorun task list.
-               */
+          /* Restore the exception context of the rtcb at the (new) head 
+           * of the g_readytorun task list.
+           */
 
-              rtcb = (struct tcb_s*)g_readytorun.head;
+          rtcb = (struct tcb_s*)g_readytorun.head;
 
-              /* Then switch contexts */
+          /* Then switch contexts */
 
-              up_restorestate(rtcb->xcp.regs);
-            }
+          up_restorestate(rtcb->xcp.regs);
+        }
 
-          /* No, then we will need to perform the user context switch */
+      /* No, then we will need to perform the user context switch */
 
-          else
-            {
-              /* Switch context to the context of the task at the head of the
-               * ready to run list.
-               */
+      else
+        {
+          /* Switch context to the context of the task at the head of the
+           * ready to run list.
+           */
 
-               struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head;
-               up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
+          struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head;
+          up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
 
-              /* up_switchcontext forces a context switch to the task at the
-               * head of the ready-to-run list.  It does not 'return' in the
-               * normal sense.  When it does return, it is because the blocked
-               * task is again ready to run and has execution priority.
-               */
-           }
+          /* up_switchcontext forces a context switch to the task at the
+           * head of the ready-to-run list.  It does not 'return' in the
+           * normal sense.  When it does return, it is because the blocked
+           * task is again ready to run and has execution priority.
+           */
         }
     }
 }
diff --git a/nuttx/arch/avr/src/common/up_assert.c b/nuttx/arch/avr/src/common/up_assert.c
index 2e70a9c28..a9012202e 100644
--- a/nuttx/arch/avr/src/common/up_assert.c
+++ b/nuttx/arch/avr/src/common/up_assert.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/avr/src/common/up_assert.c
  *
- *   Copyright (C) 2010-2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2010-2011, 2013 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -129,6 +129,7 @@ void up_assert(const uint8_t *filename, int lineno)
 #endif
 
   up_ledon(LED_ASSERTION);
+
 #ifdef CONFIG_PRINT_TASKNAME
   lldbg("Assertion failed at file:%s line: %d task: %s\n",
         filename, lineno, rtcb->name);
@@ -136,29 +137,7 @@ void up_assert(const uint8_t *filename, int lineno)
   lldbg("Assertion failed at file:%s line: %d\n",
         filename, lineno);
 #endif
-  up_dumpstate();
-  _up_assert(EXIT_FAILURE);
-}
-
-/****************************************************************************
- * Name: up_assert_code
- ****************************************************************************/
-
-void up_assert_code(const uint8_t *filename, int lineno, int errorcode)
-{
-#ifdef CONFIG_PRINT_TASKNAME
-  struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head;
-#endif
 
-  up_ledon(LED_ASSERTION);
-#ifdef CONFIG_PRINT_TASKNAME
-  lldbg("Assertion failed at file:%s line: %d task: %s error code: %d\n",
-        filename, lineno, rtcb->name, errorcode);
-#else
-  lldbg("Assertion failed at file:%s line: %d error code: %d\n",
-        filename, lineno, errorcode);
-#endif
   up_dumpstate();
-  _up_assert(errorcode);
+  _up_assert(EXIT_FAILURE);
 }
-