[incubator-nuttx] branch master updated: arch/arm: unify some duplicate code to common layer

[xiaoxiang]

This is an automated email from the ASF dual-hosted git repository.

xiaoxiang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-nuttx.git


The following commit(s) were added to refs/heads/master by this push:
     new 13889ba  arch/arm: unify some duplicate code to common layer
13889ba is described below

commit 13889ba8687132197010fed838c0da1ba6a77f52
Author: chao.an <anc...@xiaomi.com>
AuthorDate: Wed Feb 23 16:49:13 2022 +0800

    arch/arm: unify some duplicate code to common layer
    
    Signed-off-by: chao.an <anc...@xiaomi.com>
---
 arch/arm/src/arm/arm_releasepending.c              | 128 --------------
 arch/arm/src/armv6-m/arm_blocktask.c               | 148 -----------------
 arch/arm/src/armv6-m/arm_releasepending.c          | 116 -------------
 arch/arm/src/armv6-m/arm_reprioritizertr.c         | 174 -------------------
 arch/arm/src/armv6-m/arm_unblocktask.c             | 131 ---------------
 arch/arm/src/armv7-a/arm_blocktask.c               | 160 ------------------
 arch/arm/src/armv7-a/arm_reprioritizertr.c         | 184 ---------------------
 arch/arm/src/armv7-a/arm_unblocktask.c             | 144 ----------------
 arch/arm/src/armv7-m/arm_blocktask.c               | 148 -----------------
 arch/arm/src/armv7-m/arm_releasepending.c          | 120 --------------
 arch/arm/src/armv7-m/arm_reprioritizertr.c         | 174 -------------------
 arch/arm/src/armv7-m/arm_unblocktask.c             | 132 ---------------
 arch/arm/src/armv7-r/arm_blocktask.c               | 149 -----------------
 arch/arm/src/armv7-r/arm_releasepending.c          | 119 -------------
 arch/arm/src/armv7-r/arm_reprioritizertr.c         | 175 --------------------
 arch/arm/src/armv7-r/arm_unblocktask.c             | 147 ----------------
 arch/arm/src/armv8-m/arm_blocktask.c               | 148 -----------------
 arch/arm/src/armv8-m/arm_releasepending.c          | 120 --------------
 arch/arm/src/armv8-m/arm_reprioritizertr.c         | 174 -------------------
 arch/arm/src/armv8-m/arm_unblocktask.c             | 132 ---------------
 arch/arm/src/{arm => common}/arm_blocktask.c       |   2 +-
 .../src/{armv7-a => common}/arm_releasepending.c   |   2 +-
 arch/arm/src/{arm => common}/arm_reprioritizertr.c |   2 +-
 arch/arm/src/{arm => common}/arm_unblocktask.c     |   2 +-
 24 files changed, 4 insertions(+), 2927 deletions(-)

diff --git a/arch/arm/src/arm/arm_releasepending.c 
b/arch/arm/src/arm/arm_releasepending.c
deleted file mode 100644
index 5523098..0000000
--- a/arch/arm/src/arm/arm_releasepending.c
+++ /dev/null
@@ -1,128 +0,0 @@
-/****************************************************************************
- * arch/arm/src/arm/arm_releasepending.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <sched.h>
-#include <debug.h>
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "group/group.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_release_pending
- *
- * Description:
- *   Release and ready-to-run tasks that have
- *   collected in the pending task list.  This can call a
- *   context switch if a new task is placed at the head of
- *   the ready to run list.
- *
- ****************************************************************************/
-
-void up_release_pending(void)
-{
-  struct tcb_s *rtcb = this_task();
-
-  sinfo("From TCB=%p\n", rtcb);
-
-  /* Merge the g_pendingtasks list into the ready-to-run task list */
-
-  if (nxsched_merge_pending())
-    {
-      /* The currently active task has changed!  We will need to switch
-       * contexts.
-       *
-       * Update scheduler parameters.
-       */
-
-      nxsched_suspend_scheduler(rtcb);
-
-      /* Are we operating in interrupt context? */
-
-      if (CURRENT_REGS)
-        {
-          /* Yes, then we have to do things differently.
-           * Just copy the CURRENT_REGS into the OLD rtcb.
-           */
-
-           arm_savestate(rtcb->xcp.regs);
-
-          /* Restore the exception context of the rtcb at the (new) head
-           * of the ready-to-run task list.
-           */
-
-          rtcb = this_task();
-
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(rtcb);
-
-          /* Then switch contexts.  Any necessary address environment
-           * changes will be made when the interrupt returns.
-           */
-
-          arm_restorestate(rtcb->xcp.regs);
-        }
-
-      /* No, then we will need to perform the user context switch */
-
-      else
-        {
-          struct tcb_s *nexttcb = this_task();
-
-#ifdef CONFIG_ARCH_ADDRENV
-          /* Make sure that the address environment for the previously
-           * running task is closed down gracefully (data caches dump,
-           * MMU flushed) and set up the address environment for the new
-           * thread at the head of the ready-to-run list.
-           */
-
-          group_addrenv(nexttcb);
-#endif
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(nexttcb);
-
-          /* Switch context to the context of the task at the head of the
-           * ready to run list.
-           */
-
-          arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-          /* arm_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/arch/arm/src/armv6-m/arm_blocktask.c 
b/arch/arm/src/armv6-m/arm_blocktask.c
deleted file mode 100644
index fb8999b..0000000
--- a/arch/arm/src/armv6-m/arm_blocktask.c
+++ /dev/null
@@ -1,148 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv6-m/arm_blocktask.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <stdbool.h>
-#include <sched.h>
-#include <assert.h>
-#include <debug.h>
-
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_block_task
- *
- * Description:
- *   The currently executing task at the head of the ready to run list must
- *   be stopped.  Save its context and move it to the inactive list
- *   specified by task_state.
- *
- * Input Parameters:
- *   tcb: Refers to a task in the ready-to-run list (normally the task at
- *     the head of the list).  It must be stopped, its context saved and
- *     moved into one of the waiting task lists.  If it was the task at the
- *     head of the ready-to-run list, then a context switch to the new
- *     ready to run task must be performed.
- *   task_state: Specifies which waiting task list should hold the blocked
- *     task TCB.
- *
- ****************************************************************************/
-
-void up_block_task(struct tcb_s *tcb, tstate_t task_state)
-{
-  struct tcb_s *rtcb = this_task();
-  bool switch_needed;
-
-  /* Verify that the context switch can be performed */
-
-  DEBUGASSERT((tcb->task_state >= FIRST_READY_TO_RUN_STATE) &&
-              (tcb->task_state <= LAST_READY_TO_RUN_STATE));
-
-  /* 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.
-   */
-
-  switch_needed = nxsched_remove_readytorun(tcb);
-
-  /* Add the task to the specified blocked task list */
-
-  nxsched_add_blocked(tcb, (tstate_t)task_state);
-
-  /* If there are any pending tasks, then add them to the ready-to-run
-   * task list now
-   */
-
-  if (g_pendingtasks.head)
-    {
-      switch_needed |= nxsched_merge_pending();
-    }
-
-  /* Now, perform the context switch if one is needed */
-
-  if (switch_needed)
-    {
-      /* Update scheduler parameters */
-
-      nxsched_suspend_scheduler(rtcb);
-
-      /* Are we in an interrupt handler? */
-
-      if (CURRENT_REGS)
-        {
-          /* Yes, then we have to do things differently.
-           * Just copy the CURRENT_REGS into the OLD rtcb.
-           */
-
-          arm_savestate(rtcb->xcp.regs);
-
-          /* Restore the exception context of the rtcb at the (new) head
-           * of the ready-to-run task list.
-           */
-
-          rtcb = this_task();
-
-          /* Reset scheduler parameters */
-
-          nxsched_resume_scheduler(rtcb);
-
-          /* Then switch contexts */
-
-          arm_restorestate(rtcb->xcp.regs);
-        }
-
-      /* No, then we will need to perform the user context switch */
-
-      else
-        {
-          struct tcb_s *nexttcb = this_task();
-
-          /* Reset scheduler parameters */
-
-          nxsched_resume_scheduler(nexttcb);
-
-          /* Switch context to the context of the task at the head of the
-           * ready to run list.
-           */
-
-          arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-          /* arm_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/arch/arm/src/armv6-m/arm_releasepending.c 
b/arch/arm/src/armv6-m/arm_releasepending.c
deleted file mode 100644
index b2521ea..0000000
--- a/arch/arm/src/armv6-m/arm_releasepending.c
+++ /dev/null
@@ -1,116 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv6-m/arm_releasepending.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <sched.h>
-#include <debug.h>
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_release_pending
- *
- * Description:
- *   Release and ready-to-run tasks that have
- *   collected in the pending task list.  This can call a
- *   context switch if a new task is placed at the head of
- *   the ready to run list.
- *
- ****************************************************************************/
-
-void up_release_pending(void)
-{
-  struct tcb_s *rtcb = this_task();
-
-  sinfo("From TCB=%p\n", rtcb);
-
-  /* Merge the g_pendingtasks list into the ready-to-run task list */
-
-  if (nxsched_merge_pending())
-    {
-      /* The currently active task has changed!  We will need to
-       * switch contexts.
-       */
-
-      /* Update scheduler parameters */
-
-      nxsched_suspend_scheduler(rtcb);
-
-      /* Are we operating in interrupt context? */
-
-      if (CURRENT_REGS)
-        {
-          /* Yes, then we have to do things differently. Just copy the
-           * CURRENT_REGS into the OLD rtcb.
-           */
-
-           arm_savestate(rtcb->xcp.regs);
-
-          /* Restore the exception context of the rtcb at the (new) head
-           * of the ready-to-run task list.
-           */
-
-          rtcb = this_task();
-
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(rtcb);
-
-          /* Then switch contexts */
-
-          arm_restorestate(rtcb->xcp.regs);
-        }
-
-      /* No, then we will need to perform the user context switch */
-
-      else
-        {
-          struct tcb_s *nexttcb = this_task();
-
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(nexttcb);
-
-          /* Switch context to the context of the task at the head of the
-           * ready to run list.
-           */
-
-          arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-          /* arm_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/arch/arm/src/armv6-m/arm_reprioritizertr.c 
b/arch/arm/src/armv6-m/arm_reprioritizertr.c
deleted file mode 100644
index c545a00..0000000
--- a/arch/arm/src/armv6-m/arm_reprioritizertr.c
+++ /dev/null
@@ -1,174 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv6-m/arm_reprioritizertr.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <stdint.h>
-#include <stdbool.h>
-#include <sched.h>
-#include <assert.h>
-#include <debug.h>
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_reprioritize_rtr
- *
- * Description:
- *   Called when the priority of a running or
- *   ready-to-run task changes and the reprioritization will
- *   cause a context switch.  Two cases:
- *
- *   1) The priority of the currently running task drops and the next
- *      task in the ready to run list has priority.
- *   2) An idle, ready to run task's priority has been raised above the
- *      priority of the current, running task and it now has the priority.
- *
- * Input Parameters:
- *   tcb: The TCB of the task that has been reprioritized
- *   priority: The new task priority
- *
- ****************************************************************************/
-
-void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority)
-{
-  /* Verify that the caller is sane */
-
-  if (tcb->task_state < FIRST_READY_TO_RUN_STATE ||
-      tcb->task_state > LAST_READY_TO_RUN_STATE
-#if SCHED_PRIORITY_MIN > 0
-      || priority < SCHED_PRIORITY_MIN
-#endif
-#if SCHED_PRIORITY_MAX < UINT8_MAX
-      || priority > SCHED_PRIORITY_MAX
-#endif
-    )
-    {
-       DEBUGPANIC();
-    }
-  else
-    {
-      struct tcb_s *rtcb = this_task();
-      bool switch_needed;
-
-      sinfo("TCB=%p PRI=%d\n", tcb, priority);
-
-      /* Remove the tcb task from the ready-to-run list.
-       * nxsched_remove_readytorun will return true if we just removed the
-       * head of the ready to run list.
-       */
-
-      switch_needed = nxsched_remove_readytorun(tcb);
-
-      /* Setup up the new task priority */
-
-      tcb->sched_priority = (uint8_t)priority;
-
-      /* Return the task to the ready-to-run task list.
-       * nxsched_add_readytorun() will return true if the task was added to
-       * the head of ready-to-run list.  We will need to perform a context
-       * switch only if the EXCLUSIVE or of the two calls is non-zero (i.e.,
-       * one and only one the calls changes the head of the ready-to-run
-       * list).
-       */
-
-      switch_needed ^= nxsched_add_readytorun(tcb);
-
-      /* Now, perform the context switch if one is needed (i.e. if the head
-       * of the ready-to-run list is no longer the same).
-       */
-
-      if (switch_needed)
-        {
-          /* If we are going to do a context switch, then now is the right
-           * time to add any pending tasks back into the ready-to-run list.
-           */
-
-          if (g_pendingtasks.head)
-            {
-              nxsched_merge_pending();
-            }
-
-          /* Update scheduler parameters */
-
-          nxsched_suspend_scheduler(rtcb);
-
-          /* Are we in an interrupt handler? */
-
-          if (CURRENT_REGS)
-            {
-              /* Yes, then we have to do things differently.
-               * Just copy the CURRENT_REGS into the OLD rtcb.
-               */
-
-               arm_savestate(rtcb->xcp.regs);
-
-              /* Restore the exception context of the rtcb at the (new) head
-               * of the ready-to-run task list.
-               */
-
-              rtcb = this_task();
-
-              /* Update scheduler parameters */
-
-              nxsched_resume_scheduler(rtcb);
-
-              /* Then switch contexts */
-
-              arm_restorestate(rtcb->xcp.regs);
-            }
-
-          /* No, then we will need to perform the user context switch */
-
-          else
-            {
-              struct tcb_s *nexttcb = this_task();
-
-              /* Update scheduler parameters */
-
-              nxsched_resume_scheduler(nexttcb);
-
-              /* Switch context to the context of the task at the head of the
-               * ready to run list.
-               */
-
-              arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-              /* arm_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/arch/arm/src/armv6-m/arm_unblocktask.c 
b/arch/arm/src/armv6-m/arm_unblocktask.c
deleted file mode 100644
index 2d50cfe..0000000
--- a/arch/arm/src/armv6-m/arm_unblocktask.c
+++ /dev/null
@@ -1,131 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv6-m/arm_unblocktask.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <sched.h>
-#include <assert.h>
-#include <debug.h>
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "clock/clock.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_unblock_task
- *
- * Description:
- *   A task is currently in an inactive task list but has been prepped to
- *   execute.  Move the TCB to the ready-to-run list, restore its context,
- *   and start execution.
- *
- * Input Parameters:
- *   tcb: Refers to the tcb to be unblocked.  This tcb is in one of the
- *     waiting tasks lists.  It must be moved to the ready-to-run list and,
- *     if it is the highest priority ready to run task, executed.
- *
- ****************************************************************************/
-
-void up_unblock_task(struct tcb_s *tcb)
-{
-  struct tcb_s *rtcb = this_task();
-
-  /* Verify that the context switch can be performed */
-
-  DEBUGASSERT((tcb->task_state >= FIRST_BLOCKED_STATE) &&
-              (tcb->task_state <= LAST_BLOCKED_STATE));
-
-  /* Remove the task from the blocked task list */
-
-  nxsched_remove_blocked(tcb);
-
-  /* Add the task in the correct location in the prioritized
-   * ready-to-run task list
-   */
-
-  if (nxsched_add_readytorun(tcb))
-    {
-      /* The currently active task has changed! We need to do
-       * a context switch to the new task.
-       */
-
-      /* Update scheduler parameters */
-
-      nxsched_suspend_scheduler(rtcb);
-
-      /* Are we in an interrupt handler? */
-
-      if (CURRENT_REGS)
-        {
-          /* Yes, then we have to do things differently.
-           * Just copy the CURRENT_REGS into the OLD rtcb.
-           */
-
-          arm_savestate(rtcb->xcp.regs);
-
-          /* Restore the exception context of the rtcb at the (new) head
-           * of the ready-to-run task list.
-           */
-
-          rtcb = this_task();
-
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(rtcb);
-
-          /* Then switch contexts */
-
-          arm_restorestate(rtcb->xcp.regs);
-        }
-
-      /* No, then we will need to perform the user context switch */
-
-      else
-        {
-          struct tcb_s *nexttcb = this_task();
-
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(nexttcb);
-
-          /* Switch context to the context of the task at the head of the
-           * ready to run list.
-           */
-
-          arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-          /* arm_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/arch/arm/src/armv7-a/arm_blocktask.c 
b/arch/arm/src/armv7-a/arm_blocktask.c
deleted file mode 100644
index 5c22093..0000000
--- a/arch/arm/src/armv7-a/arm_blocktask.c
+++ /dev/null
@@ -1,160 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv7-a/arm_blocktask.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <stdbool.h>
-#include <sched.h>
-#include <assert.h>
-#include <debug.h>
-
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "group/group.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_block_task
- *
- * Description:
- *   The currently executing task at the head of the ready to run list must
- *   be stopped.  Save its context and move it to the inactive list
- *   specified by task_state.
- *
- * Input Parameters:
- *   tcb: Refers to a task in the ready-to-run list (normally the task at
- *     the head of the list).  It must be stopped, its context saved and
- *     moved into one of the waiting task lists.  If it was the task at the
- *     head of the ready-to-run list, then a context switch to the new
- *     ready to run task must be performed.
- *   task_state: Specifies which waiting task list should hold the blocked
- *     task TCB.
- *
- ****************************************************************************/
-
-void up_block_task(struct tcb_s *tcb, tstate_t task_state)
-{
-  struct tcb_s *rtcb = this_task();
-  bool switch_needed;
-
-  /* Verify that the context switch can be performed */
-
-  DEBUGASSERT((tcb->task_state >= FIRST_READY_TO_RUN_STATE) &&
-              (tcb->task_state <= LAST_READY_TO_RUN_STATE));
-
-  /* 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.
-   */
-
-  switch_needed = nxsched_remove_readytorun(tcb);
-
-  /* Add the task to the specified blocked task list */
-
-  nxsched_add_blocked(tcb, (tstate_t)task_state);
-
-  /* If there are any pending tasks, then add them to the ready-to-run
-   * task list now
-   */
-
-  if (g_pendingtasks.head)
-    {
-      switch_needed |= nxsched_merge_pending();
-    }
-
-  /* Now, perform the context switch if one is needed */
-
-  if (switch_needed)
-    {
-      /* Update scheduler parameters */
-
-      nxsched_suspend_scheduler(rtcb);
-
-      /* Are we in an interrupt handler? */
-
-      if (CURRENT_REGS)
-        {
-          /* Yes, then we have to do things differently.
-           * Just copy the CURRENT_REGS into the OLD rtcb.
-           */
-
-          arm_savestate(rtcb->xcp.regs);
-
-          /* Restore the exception context of the rtcb at the (new) head
-           * of the ready-to-run task list.
-           */
-
-          rtcb = this_task();
-
-          /* Reset scheduler parameters */
-
-          nxsched_resume_scheduler(rtcb);
-
-          /* Then switch contexts.  Any necessary address environment
-           * changes will be made when the interrupt returns.
-           */
-
-          arm_restorestate(rtcb->xcp.regs);
-        }
-
-      /* No, then we will need to perform the user context switch */
-
-      else
-        {
-          struct tcb_s *nexttcb = this_task();
-
-#ifdef CONFIG_ARCH_ADDRENV
-          /* Make sure that the address environment for the previously
-           * running task is closed down gracefully (data caches dump,
-           * MMU flushed) and set up the address environment for the new
-           * thread at the head of the ready-to-run list.
-           */
-
-          group_addrenv(nexttcb);
-#endif
-          /* Reset scheduler parameters */
-
-          nxsched_resume_scheduler(nexttcb);
-
-          /* Switch context to the context of the task at the head of the
-           * ready to run list.
-           */
-
-          arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-          /* arm_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/arch/arm/src/armv7-a/arm_reprioritizertr.c 
b/arch/arm/src/armv7-a/arm_reprioritizertr.c
deleted file mode 100644
index 985fe71..0000000
--- a/arch/arm/src/armv7-a/arm_reprioritizertr.c
+++ /dev/null
@@ -1,184 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv7-a/arm_reprioritizertr.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <stdint.h>
-#include <stdbool.h>
-#include <sched.h>
-#include <assert.h>
-#include <debug.h>
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "group/group.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_reprioritize_rtr
- *
- * Description:
- *   Called when the priority of a running or
- *   ready-to-run task changes and the reprioritization will
- *   cause a context switch.  Two cases:
- *
- *   1) The priority of the currently running task drops and the next
- *      task in the ready to run list has priority.
- *   2) An idle, ready to run task's priority has been raised above the
- *      priority of the current, running task and it now has the priority.
- *
- * Input Parameters:
- *   tcb: The TCB of the task that has been reprioritized
- *   priority: The new task priority
- *
- ****************************************************************************/
-
-void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority)
-{
-  /* Verify that the caller is sane */
-
-  if (tcb->task_state < FIRST_READY_TO_RUN_STATE ||
-      tcb->task_state > LAST_READY_TO_RUN_STATE
-#if SCHED_PRIORITY_MIN > 0
-      || priority < SCHED_PRIORITY_MIN
-#endif
-#if SCHED_PRIORITY_MAX < UINT8_MAX
-      || priority > SCHED_PRIORITY_MAX
-#endif
-    )
-    {
-       DEBUGPANIC();
-    }
-  else
-    {
-      struct tcb_s *rtcb = this_task();
-      bool switch_needed;
-
-      sinfo("TCB=%p PRI=%d\n", tcb, priority);
-
-      /* Remove the tcb task from the ready-to-run list.
-       * nxsched_remove_readytorun will return true if we just
-       * remove the head of the ready to run list.
-       */
-
-      switch_needed = nxsched_remove_readytorun(tcb);
-
-      /* Setup up the new task priority */
-
-      tcb->sched_priority = (uint8_t)priority;
-
-      /* Return the task to the specified blocked task list.
-       * nxsched_add_readytorun will return true if the task was
-       * added to the new list.  We will need to perform a context
-       * switch only if the EXCLUSIVE or of the two calls is non-zero
-       * (i.e., one and only one the calls changes the head of the
-       * ready-to-run list).
-       */
-
-      switch_needed ^= nxsched_add_readytorun(tcb);
-
-      /* Now, perform the context switch if one is needed */
-
-      if (switch_needed)
-        {
-          /* If we are going to do a context switch, then now is the right
-           * time to add any pending tasks back into the ready-to-run list.
-           */
-
-          if (g_pendingtasks.head)
-            {
-              nxsched_merge_pending();
-            }
-
-          /* Update scheduler parameters */
-
-          nxsched_suspend_scheduler(rtcb);
-
-          /* Are we in an interrupt handler? */
-
-          if (CURRENT_REGS)
-            {
-              /* Yes, then we have to do things differently.
-               * Just copy the CURRENT_REGS into the OLD rtcb.
-               */
-
-               arm_savestate(rtcb->xcp.regs);
-
-              /* Restore the exception context of the rtcb at the (new) head
-               * of the ready-to-run task list.
-               */
-
-              rtcb = this_task();
-
-              /* Update scheduler parameters */
-
-              nxsched_resume_scheduler(rtcb);
-
-              /* Then switch contexts.  Any necessary address environment
-               * changes will be made when the interrupt returns.
-               */
-
-              arm_restorestate(rtcb->xcp.regs);
-            }
-
-          /* No, then we will need to perform the user context switch */
-
-          else
-            {
-              struct tcb_s *nexttcb = this_task();
-
-#ifdef CONFIG_ARCH_ADDRENV
-              /* Make sure that the address environment for the previously
-               * running task is closed down gracefully (data caches dump,
-               * MMU flushed) and set up the address environment for the new
-               * thread at the head of the ready-to-run list.
-               */
-
-              group_addrenv(nexttcb);
-#endif
-              /* Update scheduler parameters */
-
-              nxsched_resume_scheduler(nexttcb);
-
-              /* Switch context to the context of the task at the head of the
-               * ready to run list.
-               */
-
-              arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-              /* arm_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/arch/arm/src/armv7-a/arm_unblocktask.c 
b/arch/arm/src/armv7-a/arm_unblocktask.c
deleted file mode 100644
index 323c09e..0000000
--- a/arch/arm/src/armv7-a/arm_unblocktask.c
+++ /dev/null
@@ -1,144 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv7-a/arm_unblocktask.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <sched.h>
-#include <assert.h>
-#include <debug.h>
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "group/group.h"
-#include "clock/clock.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_unblock_task
- *
- * Description:
- *   A task is currently in an inactive task list
- *   but has been prepped to execute.  Move the TCB to the
- *   ready-to-run list, restore its context, and start execution.
- *
- * Input Parameters:
- *   tcb: Refers to the tcb to be unblocked.  This tcb is
- *     in one of the waiting tasks lists.  It must be moved to
- *     the ready-to-run list and, if it is the highest priority
- *     ready to run task, executed.
- *
- ****************************************************************************/
-
-void up_unblock_task(struct tcb_s *tcb)
-{
-  struct tcb_s *rtcb = this_task();
-
-  /* Verify that the context switch can be performed */
-
-  DEBUGASSERT((tcb->task_state >= FIRST_BLOCKED_STATE) &&
-              (tcb->task_state <= LAST_BLOCKED_STATE));
-
-  /* Remove the task from the blocked task list */
-
-  nxsched_remove_blocked(tcb);
-
-  /* Add the task in the correct location in the prioritized
-   * ready-to-run task list
-   */
-
-  if (nxsched_add_readytorun(tcb))
-    {
-      /* The currently active task has changed! We need to do
-       * a context switch to the new task.
-       */
-
-      /* Update scheduler parameters */
-
-      nxsched_suspend_scheduler(rtcb);
-
-      /* Are we in an interrupt handler? */
-
-      if (CURRENT_REGS)
-        {
-          /* Yes, then we have to do things differently.
-           * Just copy the CURRENT_REGS into the OLD rtcb.
-           */
-
-          arm_savestate(rtcb->xcp.regs);
-
-          /* Restore the exception context of the rtcb at the (new) head
-           * of the ready-to-run task list.
-           */
-
-          rtcb = this_task();
-
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(rtcb);
-
-          /* Then switch contexts.  Any necessary address environment
-           * changes will be made when the interrupt returns.
-           */
-
-          arm_restorestate(rtcb->xcp.regs);
-        }
-
-      /* No, then we will need to perform the user context switch */
-
-      else
-        {
-          struct tcb_s *nexttcb = this_task();
-
-#ifdef CONFIG_ARCH_ADDRENV
-          /* Make sure that the address environment for the previously
-           * running task is closed down gracefully (data caches dump,
-           * MMU flushed) and set up the address environment for the new
-           * thread at the head of the ready-to-run list.
-           */
-
-          group_addrenv(nexttcb);
-#endif
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(nexttcb);
-
-          /* Switch context to the context of the task at the head of the
-           * ready to run list.
-           */
-
-          arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-          /* arm_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/arch/arm/src/armv7-m/arm_blocktask.c 
b/arch/arm/src/armv7-m/arm_blocktask.c
deleted file mode 100644
index a55b9b9..0000000
--- a/arch/arm/src/armv7-m/arm_blocktask.c
+++ /dev/null
@@ -1,148 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv7-m/arm_blocktask.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <stdbool.h>
-#include <sched.h>
-#include <assert.h>
-#include <debug.h>
-
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_block_task
- *
- * Description:
- *   The currently executing task at the head of the ready to run list must
- *   be stopped.  Save its context and move it to the inactive list
- *   specified by task_state.
- *
- * Input Parameters:
- *   tcb: Refers to a task in the ready-to-run list (normally the task at
- *     the head of the list).  It must be stopped, its context saved and
- *     moved into one of the waiting task lists.  If it was the task at the
- *     head of the ready-to-run list, then a context switch to the new
- *     ready to run task must be performed.
- *   task_state: Specifies which waiting task list should hold the blocked
- *     task TCB.
- *
- ****************************************************************************/
-
-void up_block_task(struct tcb_s *tcb, tstate_t task_state)
-{
-  struct tcb_s *rtcb = this_task();
-  bool switch_needed;
-
-  /* Verify that the context switch can be performed */
-
-  DEBUGASSERT((tcb->task_state >= FIRST_READY_TO_RUN_STATE) &&
-              (tcb->task_state <= LAST_READY_TO_RUN_STATE));
-
-  /* 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.
-   */
-
-  switch_needed = nxsched_remove_readytorun(tcb);
-
-  /* Add the task to the specified blocked task list */
-
-  nxsched_add_blocked(tcb, (tstate_t)task_state);
-
-  /* If there are any pending tasks, then add them to the ready-to-run
-   * task list now
-   */
-
-  if (g_pendingtasks.head)
-    {
-      switch_needed |= nxsched_merge_pending();
-    }
-
-  /* Now, perform the context switch if one is needed */
-
-  if (switch_needed)
-    {
-      /* Update scheduler parameters */
-
-      nxsched_suspend_scheduler(rtcb);
-
-      /* Are we in an interrupt handler? */
-
-      if (CURRENT_REGS)
-        {
-          /* Yes, then we have to do things differently.
-           * Just copy the CURRENT_REGS into the OLD rtcb.
-           */
-
-          arm_savestate(rtcb->xcp.regs);
-
-          /* Restore the exception context of the rtcb at the (new) head
-           * of the ready-to-run task list.
-           */
-
-          rtcb = this_task();
-
-          /* Reset scheduler parameters */
-
-          nxsched_resume_scheduler(rtcb);
-
-          /* Then switch contexts */
-
-          arm_restorestate(rtcb->xcp.regs);
-        }
-
-      /* No, then we will need to perform the user context switch */
-
-      else
-        {
-          struct tcb_s *nexttcb = this_task();
-
-          /* Reset scheduler parameters */
-
-          nxsched_resume_scheduler(nexttcb);
-
-          /* Switch context to the context of the task at the head of the
-           * ready to run list.
-           */
-
-          arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-          /* arm_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/arch/arm/src/armv7-m/arm_releasepending.c 
b/arch/arm/src/armv7-m/arm_releasepending.c
deleted file mode 100644
index b4dbf0b..0000000
--- a/arch/arm/src/armv7-m/arm_releasepending.c
+++ /dev/null
@@ -1,120 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv7-m/arm_releasepending.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <sched.h>
-#include <debug.h>
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_release_pending
- *
- * Description:
- *   Release and ready-to-run tasks that have
- *   collected in the pending task list.  This can call a
- *   context switch if a new task is placed at the head of
- *   the ready to run list.
- *
- ****************************************************************************/
-
-void up_release_pending(void)
-{
-  struct tcb_s *rtcb = this_task();
-
-  sinfo("From TCB=%p\n", rtcb);
-
-  /* Merge the g_pendingtasks list into the ready-to-run task list */
-
-#if 0
-  sched_lock();
-#endif
-
-  if (nxsched_merge_pending())
-    {
-      /* The currently active task has changed!  We will need to switch
-       * contexts.
-       */
-
-      /* Update scheduler parameters */
-
-      nxsched_suspend_scheduler(rtcb);
-
-      /* Are we operating in interrupt context? */
-
-      if (CURRENT_REGS)
-        {
-          /* Yes, then we have to do things differently. Just copy the
-           * CURRENT_REGS into the OLD rtcb.
-           */
-
-           arm_savestate(rtcb->xcp.regs);
-
-          /* Restore the exception context of the rtcb at the (new) head
-           * of the ready-to-run task list.
-           */
-
-          rtcb = this_task();
-
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(rtcb);
-
-          /* Then switch contexts */
-
-          arm_restorestate(rtcb->xcp.regs);
-        }
-
-      /* No, then we will need to perform the user context switch */
-
-      else
-        {
-          struct tcb_s *nexttcb = this_task();
-
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(nexttcb);
-
-          /* Switch context to the context of the task at the head of the
-           * ready to run list.
-           */
-
-          arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-          /* arm_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/arch/arm/src/armv7-m/arm_reprioritizertr.c 
b/arch/arm/src/armv7-m/arm_reprioritizertr.c
deleted file mode 100644
index 4dbe8f2..0000000
--- a/arch/arm/src/armv7-m/arm_reprioritizertr.c
+++ /dev/null
@@ -1,174 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv7-m/arm_reprioritizertr.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <stdint.h>
-#include <stdbool.h>
-#include <sched.h>
-#include <assert.h>
-#include <debug.h>
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_reprioritize_rtr
- *
- * Description:
- *   Called when the priority of a running or
- *   ready-to-run task changes and the reprioritization will
- *   cause a context switch.  Two cases:
- *
- *   1) The priority of the currently running task drops and the next
- *      task in the ready to run list has priority.
- *   2) An idle, ready to run task's priority has been raised above the
- *      priority of the current, running task and it now has the priority.
- *
- * Input Parameters:
- *   tcb: The TCB of the task that has been reprioritized
- *   priority: The new task priority
- *
- ****************************************************************************/
-
-void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority)
-{
-  /* Verify that the caller is sane */
-
-  if (tcb->task_state < FIRST_READY_TO_RUN_STATE ||
-      tcb->task_state > LAST_READY_TO_RUN_STATE
-#if SCHED_PRIORITY_MIN > 0
-      || priority < SCHED_PRIORITY_MIN
-#endif
-#if SCHED_PRIORITY_MAX < UINT8_MAX
-      || priority > SCHED_PRIORITY_MAX
-#endif
-    )
-    {
-       DEBUGPANIC();
-    }
-  else
-    {
-      struct tcb_s *rtcb = this_task();
-      bool switch_needed;
-
-      sinfo("TCB=%p PRI=%d\n", tcb, priority);
-
-      /* Remove the tcb task from the ready-to-run list.
-       * nxsched_remove_readytorun will return true if we just removed the
-       * head of the ready to run list.
-       */
-
-      switch_needed = nxsched_remove_readytorun(tcb);
-
-      /* Setup up the new task priority */
-
-      tcb->sched_priority = (uint8_t)priority;
-
-      /* Return the task to the ready-to-run task list.
-       * nxsched_add_readytorun() will return true if the task was added to
-       * the head of ready-to-run list.  We will need to perform a context
-       * switch only if the EXCLUSIVE or of the two calls is non-zero (i.e.,
-       * one and only one the calls changes the head of the ready-to-run
-       * list).
-       */
-
-      switch_needed ^= nxsched_add_readytorun(tcb);
-
-      /* Now, perform the context switch if one is needed (i.e. if the head
-       * of the ready-to-run list is no longer the same).
-       */
-
-      if (switch_needed)
-        {
-          /* If we are going to do a context switch, then now is the right
-           * time to add any pending tasks back into the ready-to-run list.
-           */
-
-          if (g_pendingtasks.head)
-            {
-              nxsched_merge_pending();
-            }
-
-          /* Update scheduler parameters */
-
-          nxsched_suspend_scheduler(rtcb);
-
-          /* Are we in an interrupt handler? */
-
-          if (CURRENT_REGS)
-            {
-              /* Yes, then we have to do things differently.
-               * Just copy the CURRENT_REGS into the OLD rtcb.
-               */
-
-               arm_savestate(rtcb->xcp.regs);
-
-              /* Restore the exception context of the rtcb at the (new) head
-               * of the ready-to-run task list.
-               */
-
-              rtcb = this_task();
-
-              /* Update scheduler parameters */
-
-              nxsched_resume_scheduler(rtcb);
-
-              /* Then switch contexts */
-
-              arm_restorestate(rtcb->xcp.regs);
-            }
-
-          /* No, then we will need to perform the user context switch */
-
-          else
-            {
-              struct tcb_s *nexttcb = this_task();
-
-              /* Update scheduler parameters */
-
-              nxsched_resume_scheduler(nexttcb);
-
-              /* Switch context to the context of the task at the head of the
-               * ready to run list.
-               */
-
-              arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-              /* arm_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/arch/arm/src/armv7-m/arm_unblocktask.c 
b/arch/arm/src/armv7-m/arm_unblocktask.c
deleted file mode 100644
index 4a96c33..0000000
--- a/arch/arm/src/armv7-m/arm_unblocktask.c
+++ /dev/null
@@ -1,132 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv7-m/arm_unblocktask.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <sched.h>
-#include <assert.h>
-#include <debug.h>
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "clock/clock.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_unblock_task
- *
- * Description:
- *   A task is currently in an inactive task list
- *   but has been prepped to execute.  Move the TCB to the
- *   ready-to-run list, restore its context, and start execution.
- *
- * Input Parameters:
- *   tcb: Refers to the tcb to be unblocked.  This tcb is
- *     in one of the waiting tasks lists.  It must be moved to
- *     the ready-to-run list and, if it is the highest priority
- *     ready to run task, executed.
- *
- ****************************************************************************/
-
-void up_unblock_task(struct tcb_s *tcb)
-{
-  struct tcb_s *rtcb = this_task();
-
-  /* Verify that the context switch can be performed */
-
-  DEBUGASSERT((tcb->task_state >= FIRST_BLOCKED_STATE) &&
-              (tcb->task_state <= LAST_BLOCKED_STATE));
-
-  /* Remove the task from the blocked task list */
-
-  nxsched_remove_blocked(tcb);
-
-  /* Add the task in the correct location in the prioritized
-   * ready-to-run task list
-   */
-
-  if (nxsched_add_readytorun(tcb))
-    {
-      /* The currently active task has changed! We need to do
-       * a context switch to the new task.
-       */
-
-      /* Update scheduler parameters */
-
-      nxsched_suspend_scheduler(rtcb);
-
-      /* Are we in an interrupt handler? */
-
-      if (CURRENT_REGS)
-        {
-          /* Yes, then we have to do things differently.
-           * Just copy the CURRENT_REGS into the OLD rtcb.
-           */
-
-          arm_savestate(rtcb->xcp.regs);
-
-          /* Restore the exception context of the rtcb at the (new) head
-           * of the ready-to-run task list.
-           */
-
-          rtcb = this_task();
-
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(rtcb);
-
-          /* Then switch contexts */
-
-          arm_restorestate(rtcb->xcp.regs);
-        }
-
-      /* No, then we will need to perform the user context switch */
-
-      else
-        {
-          struct tcb_s *nexttcb = this_task();
-
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(nexttcb);
-
-          /* Switch context to the context of the task at the head of the
-           * ready to run list.
-           */
-
-          arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-          /* arm_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/arch/arm/src/armv7-r/arm_blocktask.c 
b/arch/arm/src/armv7-r/arm_blocktask.c
deleted file mode 100644
index 7e5dacb..0000000
--- a/arch/arm/src/armv7-r/arm_blocktask.c
+++ /dev/null
@@ -1,149 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv7-r/arm_blocktask.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <stdbool.h>
-#include <sched.h>
-#include <assert.h>
-#include <debug.h>
-
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "group/group.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_block_task
- *
- * Description:
- *   The currently executing task at the head of the ready to run list must
- *   be stopped.  Save its context and move it to the inactive list
- *   specified by task_state.
- *
- * Input Parameters:
- *   tcb: Refers to a task in the ready-to-run list (normally the task at
- *     the head of the list).  It must be stopped, its context saved and
- *     moved into one of the waiting task lists.  If it was the task at the
- *     head of the ready-to-run list, then a context switch to the new
- *     ready to run task must be performed.
- *   task_state: Specifies which waiting task list should hold the blocked
- *     task TCB.
- *
- ****************************************************************************/
-
-void up_block_task(struct tcb_s *tcb, tstate_t task_state)
-{
-  struct tcb_s *rtcb = this_task();
-  bool switch_needed;
-
-  /* Verify that the context switch can be performed */
-
-  DEBUGASSERT((tcb->task_state >= FIRST_READY_TO_RUN_STATE) &&
-              (tcb->task_state <= LAST_READY_TO_RUN_STATE));
-
-  /* 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.
-   */
-
-  switch_needed = nxsched_remove_readytorun(tcb);
-
-  /* Add the task to the specified blocked task list */
-
-  nxsched_add_blocked(tcb, (tstate_t)task_state);
-
-  /* If there are any pending tasks, then add them to the ready-to-run
-   * task list now
-   */
-
-  if (g_pendingtasks.head)
-    {
-      switch_needed |= nxsched_merge_pending();
-    }
-
-  /* Now, perform the context switch if one is needed */
-
-  if (switch_needed)
-    {
-      /* Update scheduler parameters */
-
-      nxsched_suspend_scheduler(rtcb);
-
-      /* Are we in an interrupt handler? */
-
-      if (CURRENT_REGS)
-        {
-          /* Yes, then we have to do things differently.
-           * Just copy the CURRENT_REGS into the OLD rtcb.
-           */
-
-          arm_savestate(rtcb->xcp.regs);
-
-          /* Restore the exception context of the rtcb at the (new) head
-           * of the ready-to-run task list.
-           */
-
-          rtcb = this_task();
-
-          /* Reset scheduler parameters */
-
-          nxsched_resume_scheduler(rtcb);
-
-          /* Then switch contexts. */
-
-          arm_restorestate(rtcb->xcp.regs);
-        }
-
-      /* No, then we will need to perform the user context switch */
-
-      else
-        {
-          struct tcb_s *nexttcb = this_task();
-
-          /* Reset scheduler parameters */
-
-          nxsched_resume_scheduler(nexttcb);
-
-          /* Switch context to the context of the task at the head of the
-           * ready to run list.
-           */
-
-          arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-          /* arm_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/arch/arm/src/armv7-r/arm_releasepending.c 
b/arch/arm/src/armv7-r/arm_releasepending.c
deleted file mode 100644
index 43b78f2..0000000
--- a/arch/arm/src/armv7-r/arm_releasepending.c
+++ /dev/null
@@ -1,119 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv7-r/arm_releasepending.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <sched.h>
-#include <debug.h>
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "group/group.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_release_pending
- *
- * Description:
- *   Release and ready-to-run tasks that have
- *   collected in the pending task list.  This can call a
- *   context switch if a new task is placed at the head of
- *   the ready to run list.
- *
- ****************************************************************************/
-
-void up_release_pending(void)
-{
-  struct tcb_s *rtcb = this_task();
-
-  sinfo("From TCB=%p\n", rtcb);
-
-  /* Merge the g_pendingtasks list into the ready-to-run task list */
-
-  if (nxsched_merge_pending())
-    {
-      /* The currently active task has changed!  We will need to
-       * switch contexts.
-       */
-
-      /* Update scheduler parameters */
-
-      nxsched_suspend_scheduler(rtcb);
-
-      /* Are we operating in interrupt context? */
-
-      if (CURRENT_REGS)
-        {
-          /* Yes, then we have to do things differently.
-           * Just copy the CURRENT_REGS into the OLD rtcb.
-           */
-
-           arm_savestate(rtcb->xcp.regs);
-
-          /* Restore the exception context of the rtcb at the (new) head
-           * of the ready-to-run task list.
-           */
-
-          rtcb = this_task();
-
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(rtcb);
-
-          /* Then switch contexts.  Any necessary address environment
-           * changes will be made when the interrupt returns.
-           */
-
-          arm_restorestate(rtcb->xcp.regs);
-        }
-
-      /* No, then we will need to perform the user context switch */
-
-      else
-        {
-          struct tcb_s *nexttcb = this_task();
-
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(nexttcb);
-
-          /* Switch context to the context of the task at the head of the
-           * ready to run list.
-           */
-
-          arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-          /* arm_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/arch/arm/src/armv7-r/arm_reprioritizertr.c 
b/arch/arm/src/armv7-r/arm_reprioritizertr.c
deleted file mode 100644
index 6852177..0000000
--- a/arch/arm/src/armv7-r/arm_reprioritizertr.c
+++ /dev/null
@@ -1,175 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv7-r/arm_reprioritizertr.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <stdint.h>
-#include <stdbool.h>
-#include <sched.h>
-#include <assert.h>
-#include <debug.h>
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "group/group.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_reprioritize_rtr
- *
- * Description:
- *   Called when the priority of a running or
- *   ready-to-run task changes and the reprioritization will
- *   cause a context switch.  Two cases:
- *
- *   1) The priority of the currently running task drops and the next
- *      task in the ready to run list has priority.
- *   2) An idle, ready to run task's priority has been raised above the
- *      priority of the current, running task and it now has the priority.
- *
- * Input Parameters:
- *   tcb: The TCB of the task that has been reprioritized
- *   priority: The new task priority
- *
- ****************************************************************************/
-
-void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority)
-{
-  /* Verify that the caller is sane */
-
-  if (tcb->task_state < FIRST_READY_TO_RUN_STATE ||
-      tcb->task_state > LAST_READY_TO_RUN_STATE
-#if SCHED_PRIORITY_MIN > 0
-      || priority < SCHED_PRIORITY_MIN
-#endif
-#if SCHED_PRIORITY_MAX < UINT8_MAX
-      || priority > SCHED_PRIORITY_MAX
-#endif
-    )
-    {
-       DEBUGPANIC();
-    }
-  else
-    {
-      struct tcb_s *rtcb = this_task();
-      bool switch_needed;
-
-      sinfo("TCB=%p PRI=%d\n", tcb, priority);
-
-      /* Remove the tcb task from the ready-to-run list.
-       * nxsched_remove_readytorun will return true if we just
-       * remove the head of the ready to run list.
-       */
-
-      switch_needed = nxsched_remove_readytorun(tcb);
-
-      /* Setup up the new task priority */
-
-      tcb->sched_priority = (uint8_t)priority;
-
-      /* Return the task to the specified blocked task list.
-       * nxsched_add_readytorun will return true if the task was
-       * added to the new list.  We will need to perform a context
-       * switch only if the EXCLUSIVE or of the two calls is non-zero
-       * (i.e., one and only one the calls changes the head of the
-       * ready-to-run list).
-       */
-
-      switch_needed ^= nxsched_add_readytorun(tcb);
-
-      /* Now, perform the context switch if one is needed */
-
-      if (switch_needed)
-        {
-          /* If we are going to do a context switch, then now is the right
-           * time to add any pending tasks back into the ready-to-run list.
-           */
-
-          if (g_pendingtasks.head)
-            {
-              nxsched_merge_pending();
-            }
-
-          /* Update scheduler parameters */
-
-          nxsched_suspend_scheduler(rtcb);
-
-          /* Are we in an interrupt handler? */
-
-          if (CURRENT_REGS)
-            {
-              /* Yes, then we have to do things differently.
-               * Just copy the CURRENT_REGS into the OLD rtcb.
-               */
-
-               arm_savestate(rtcb->xcp.regs);
-
-              /* Restore the exception context of the rtcb at the (new) head
-               * of the ready-to-run task list.
-               */
-
-              rtcb = this_task();
-
-              /* Update scheduler parameters */
-
-              nxsched_resume_scheduler(rtcb);
-
-              /* Then switch contexts.  Any necessary address environment
-               * changes will be made when the interrupt returns.
-               */
-
-              arm_restorestate(rtcb->xcp.regs);
-            }
-
-          /* No, then we will need to perform the user context switch */
-
-          else
-            {
-              struct tcb_s *nexttcb = this_task();
-
-              /* Update scheduler parameters */
-
-              nxsched_resume_scheduler(nexttcb);
-
-              /* Switch context to the context of the task at the head of the
-               * ready to run list.
-               */
-
-              arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-              /* arm_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/arch/arm/src/armv7-r/arm_unblocktask.c 
b/arch/arm/src/armv7-r/arm_unblocktask.c
deleted file mode 100644
index d10d7a2..0000000
--- a/arch/arm/src/armv7-r/arm_unblocktask.c
+++ /dev/null
@@ -1,147 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv7-r/arm_unblocktask.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <sched.h>
-#include <assert.h>
-#include <debug.h>
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "group/group.h"
-#include "clock/clock.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Pre-processor Definitions
- ****************************************************************************/
-
-/****************************************************************************
- * Private Data
- ****************************************************************************/
-
-/****************************************************************************
- * Private Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_unblock_task
- *
- * Description:
- *   A task is currently in an inactive task list
- *   but has been prepped to execute.  Move the TCB to the
- *   ready-to-run list, restore its context, and start execution.
- *
- * Input Parameters:
- *   tcb: Refers to the tcb to be unblocked.  This tcb is
- *     in one of the waiting tasks lists.  It must be moved to
- *     the ready-to-run list and, if it is the highest priority
- *     ready to run task, executed.
- *
- ****************************************************************************/
-
-void up_unblock_task(struct tcb_s *tcb)
-{
-  struct tcb_s *rtcb = this_task();
-
-  /* Verify that the context switch can be performed */
-
-  DEBUGASSERT((tcb->task_state >= FIRST_BLOCKED_STATE) &&
-              (tcb->task_state <= LAST_BLOCKED_STATE));
-
-  /* Remove the task from the blocked task list */
-
-  nxsched_remove_blocked(tcb);
-
-  /* Add the task in the correct location in the prioritized
-   * ready-to-run task list
-   */
-
-  if (nxsched_add_readytorun(tcb))
-    {
-      /* The currently active task has changed! We need to do
-       * a context switch to the new task.
-       */
-
-      /* Update scheduler parameters */
-
-      nxsched_suspend_scheduler(rtcb);
-
-      /* Are we in an interrupt handler? */
-
-      if (CURRENT_REGS)
-        {
-          /* Yes, then we have to do things differently.
-           * Just copy the CURRENT_REGS into the OLD rtcb.
-           */
-
-          arm_savestate(rtcb->xcp.regs);
-
-          /* Restore the exception context of the rtcb at the (new) head
-           * of the ready-to-run task list.
-           */
-
-          rtcb = this_task();
-
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(rtcb);
-
-          /* Then switch contexts.  Any necessary address environment
-           * changes will be made when the interrupt returns.
-           */
-
-          arm_restorestate(rtcb->xcp.regs);
-        }
-
-      /* No, then we will need to perform the user context switch */
-
-      else
-        {
-          struct tcb_s *nexttcb = this_task();
-
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(nexttcb);
-
-          /* Switch context to the context of the task at the head of the
-           * ready to run list.
-           */
-
-          arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-          /* arm_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/arch/arm/src/armv8-m/arm_blocktask.c 
b/arch/arm/src/armv8-m/arm_blocktask.c
deleted file mode 100644
index 30a1e5a..0000000
--- a/arch/arm/src/armv8-m/arm_blocktask.c
+++ /dev/null
@@ -1,148 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv8-m/arm_blocktask.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <stdbool.h>
-#include <sched.h>
-#include <assert.h>
-#include <debug.h>
-
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_block_task
- *
- * Description:
- *   The currently executing task at the head of the ready to run list must
- *   be stopped.  Save its context and move it to the inactive list
- *   specified by task_state.
- *
- * Input Parameters:
- *   tcb: Refers to a task in the ready-to-run list (normally the task at
- *     the head of the list).  It must be stopped, its context saved and
- *     moved into one of the waiting task lists.  If it was the task at the
- *     head of the ready-to-run list, then a context switch to the new
- *     ready to run task must be performed.
- *   task_state: Specifies which waiting task list should hold the blocked
- *     task TCB.
- *
- ****************************************************************************/
-
-void up_block_task(struct tcb_s *tcb, tstate_t task_state)
-{
-  struct tcb_s *rtcb = this_task();
-  bool switch_needed;
-
-  /* Verify that the context switch can be performed */
-
-  DEBUGASSERT((tcb->task_state >= FIRST_READY_TO_RUN_STATE) &&
-              (tcb->task_state <= LAST_READY_TO_RUN_STATE));
-
-  /* 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.
-   */
-
-  switch_needed = nxsched_remove_readytorun(tcb);
-
-  /* Add the task to the specified blocked task list */
-
-  nxsched_add_blocked(tcb, (tstate_t)task_state);
-
-  /* If there are any pending tasks, then add them to the ready-to-run
-   * task list now
-   */
-
-  if (g_pendingtasks.head)
-    {
-      switch_needed |= nxsched_merge_pending();
-    }
-
-  /* Now, perform the context switch if one is needed */
-
-  if (switch_needed)
-    {
-      /* Update scheduler parameters */
-
-      nxsched_suspend_scheduler(rtcb);
-
-      /* Are we in an interrupt handler? */
-
-      if (CURRENT_REGS)
-        {
-          /* Yes, then we have to do things differently.
-           * Just copy the CURRENT_REGS into the OLD rtcb.
-           */
-
-          arm_savestate(rtcb->xcp.regs);
-
-          /* Restore the exception context of the rtcb at the (new) head
-           * of the ready-to-run task list.
-           */
-
-          rtcb = this_task();
-
-          /* Reset scheduler parameters */
-
-          nxsched_resume_scheduler(rtcb);
-
-          /* Then switch contexts */
-
-          arm_restorestate(rtcb->xcp.regs);
-        }
-
-      /* No, then we will need to perform the user context switch */
-
-      else
-        {
-          struct tcb_s *nexttcb = this_task();
-
-          /* Reset scheduler parameters */
-
-          nxsched_resume_scheduler(nexttcb);
-
-          /* Switch context to the context of the task at the head of the
-           * ready to run list.
-           */
-
-          arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-          /* arm_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/arch/arm/src/armv8-m/arm_releasepending.c 
b/arch/arm/src/armv8-m/arm_releasepending.c
deleted file mode 100644
index 1574a2e..0000000
--- a/arch/arm/src/armv8-m/arm_releasepending.c
+++ /dev/null
@@ -1,120 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv8-m/arm_releasepending.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <sched.h>
-#include <debug.h>
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_release_pending
- *
- * Description:
- *   Release and ready-to-run tasks that have
- *   collected in the pending task list.  This can call a
- *   context switch if a new task is placed at the head of
- *   the ready to run list.
- *
- ****************************************************************************/
-
-void up_release_pending(void)
-{
-  struct tcb_s *rtcb = this_task();
-
-  sinfo("From TCB=%p\n", rtcb);
-
-  /* Merge the g_pendingtasks list into the ready-to-run task list */
-
-#if 0
-  sched_lock();
-#endif
-
-  if (nxsched_merge_pending())
-    {
-      /* The currently active task has changed!  We will need to switch
-       * contexts.
-       */
-
-      /* Update scheduler parameters */
-
-      nxsched_suspend_scheduler(rtcb);
-
-      /* Are we operating in interrupt context? */
-
-      if (CURRENT_REGS)
-        {
-          /* Yes, then we have to do things differently. Just copy the
-           * CURRENT_REGS into the OLD rtcb.
-           */
-
-           arm_savestate(rtcb->xcp.regs);
-
-          /* Restore the exception context of the rtcb at the (new) head
-           * of the ready-to-run task list.
-           */
-
-          rtcb = this_task();
-
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(rtcb);
-
-          /* Then switch contexts */
-
-          arm_restorestate(rtcb->xcp.regs);
-        }
-
-      /* No, then we will need to perform the user context switch */
-
-      else
-        {
-          struct tcb_s *nexttcb = this_task();
-
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(nexttcb);
-
-          /* Switch context to the context of the task at the head of the
-           * ready to run list.
-           */
-
-          arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-          /* arm_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/arch/arm/src/armv8-m/arm_reprioritizertr.c 
b/arch/arm/src/armv8-m/arm_reprioritizertr.c
deleted file mode 100644
index e7f0a22..0000000
--- a/arch/arm/src/armv8-m/arm_reprioritizertr.c
+++ /dev/null
@@ -1,174 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv8-m/arm_reprioritizertr.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <stdint.h>
-#include <stdbool.h>
-#include <sched.h>
-#include <assert.h>
-#include <debug.h>
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_reprioritize_rtr
- *
- * Description:
- *   Called when the priority of a running or
- *   ready-to-run task changes and the reprioritization will
- *   cause a context switch.  Two cases:
- *
- *   1) The priority of the currently running task drops and the next
- *      task in the ready to run list has priority.
- *   2) An idle, ready to run task's priority has been raised above the
- *      priority of the current, running task and it now has the priority.
- *
- * Input Parameters:
- *   tcb: The TCB of the task that has been reprioritized
- *   priority: The new task priority
- *
- ****************************************************************************/
-
-void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority)
-{
-  /* Verify that the caller is sane */
-
-  if (tcb->task_state < FIRST_READY_TO_RUN_STATE ||
-      tcb->task_state > LAST_READY_TO_RUN_STATE
-#if SCHED_PRIORITY_MIN > 0
-      || priority < SCHED_PRIORITY_MIN
-#endif
-#if SCHED_PRIORITY_MAX < UINT8_MAX
-      || priority > SCHED_PRIORITY_MAX
-#endif
-    )
-    {
-       DEBUGPANIC();
-    }
-  else
-    {
-      struct tcb_s *rtcb = this_task();
-      bool switch_needed;
-
-      sinfo("TCB=%p PRI=%d\n", tcb, priority);
-
-      /* Remove the tcb task from the ready-to-run list.
-       * nxsched_remove_readytorun() will return true if we just removed the
-       * head of the ready to run list.
-       */
-
-      switch_needed = nxsched_remove_readytorun(tcb);
-
-      /* Setup up the new task priority */
-
-      tcb->sched_priority = (uint8_t)priority;
-
-      /* Return the task to the ready-to-run task list.
-       * nxsched_add_readytorun() will return true if the task was added to
-       * the head of ready-to-run list.  We will need to perform a context
-       * switch only if the EXCLUSIVE or of the two calls is non-zero (i.e.,
-       * one and only one the calls changes the head of the ready-to-run
-       * list).
-       */
-
-      switch_needed ^= nxsched_add_readytorun(tcb);
-
-      /* Now, perform the context switch if one is needed (i.e. if the head
-       * of the ready-to-run list is no longer the same).
-       */
-
-      if (switch_needed)
-        {
-          /* If we are going to do a context switch, then now is the right
-           * time to add any pending tasks back into the ready-to-run list.
-           */
-
-          if (g_pendingtasks.head)
-            {
-              nxsched_merge_pending();
-            }
-
-          /* Update scheduler parameters */
-
-          nxsched_suspend_scheduler(rtcb);
-
-          /* Are we in an interrupt handler? */
-
-          if (CURRENT_REGS)
-            {
-              /* Yes, then we have to do things differently.
-               * Just copy the CURRENT_REGS into the OLD rtcb.
-               */
-
-               arm_savestate(rtcb->xcp.regs);
-
-              /* Restore the exception context of the rtcb at the (new) head
-               * of the ready-to-run task list.
-               */
-
-              rtcb = this_task();
-
-              /* Update scheduler parameters */
-
-              nxsched_resume_scheduler(rtcb);
-
-              /* Then switch contexts */
-
-              arm_restorestate(rtcb->xcp.regs);
-            }
-
-          /* No, then we will need to perform the user context switch */
-
-          else
-            {
-              struct tcb_s *nexttcb = this_task();
-
-              /* Update scheduler parameters */
-
-              nxsched_resume_scheduler(nexttcb);
-
-              /* Switch context to the context of the task at the head of the
-               * ready to run list.
-               */
-
-              arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-              /* arm_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/arch/arm/src/armv8-m/arm_unblocktask.c 
b/arch/arm/src/armv8-m/arm_unblocktask.c
deleted file mode 100644
index 2af7852..0000000
--- a/arch/arm/src/armv8-m/arm_unblocktask.c
+++ /dev/null
@@ -1,132 +0,0 @@
-/****************************************************************************
- * arch/arm/src/armv8-m/arm_unblocktask.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <sched.h>
-#include <assert.h>
-#include <debug.h>
-#include <nuttx/arch.h>
-#include <nuttx/sched.h>
-
-#include "sched/sched.h"
-#include "clock/clock.h"
-#include "arm_internal.h"
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: up_unblock_task
- *
- * Description:
- *   A task is currently in an inactive task list
- *   but has been prepped to execute.  Move the TCB to the
- *   ready-to-run list, restore its context, and start execution.
- *
- * Input Parameters:
- *   tcb: Refers to the tcb to be unblocked.  This tcb is
- *     in one of the waiting tasks lists.  It must be moved to
- *     the ready-to-run list and, if it is the highest priority
- *     ready to run task, executed.
- *
- ****************************************************************************/
-
-void up_unblock_task(struct tcb_s *tcb)
-{
-  struct tcb_s *rtcb = this_task();
-
-  /* Verify that the context switch can be performed */
-
-  DEBUGASSERT((tcb->task_state >= FIRST_BLOCKED_STATE) &&
-              (tcb->task_state <= LAST_BLOCKED_STATE));
-
-  /* Remove the task from the blocked task list */
-
-  nxsched_remove_blocked(tcb);
-
-  /* Add the task in the correct location in the prioritized
-   * ready-to-run task list
-   */
-
-  if (nxsched_add_readytorun(tcb))
-    {
-      /* The currently active task has changed! We need to do
-       * a context switch to the new task.
-       */
-
-      /* Update scheduler parameters */
-
-      nxsched_suspend_scheduler(rtcb);
-
-      /* Are we in an interrupt handler? */
-
-      if (CURRENT_REGS)
-        {
-          /* Yes, then we have to do things differently.
-           * Just copy the CURRENT_REGS into the OLD rtcb.
-           */
-
-          arm_savestate(rtcb->xcp.regs);
-
-          /* Restore the exception context of the rtcb at the (new) head
-           * of the ready-to-run task list.
-           */
-
-          rtcb = this_task();
-
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(rtcb);
-
-          /* Then switch contexts */
-
-          arm_restorestate(rtcb->xcp.regs);
-        }
-
-      /* No, then we will need to perform the user context switch */
-
-      else
-        {
-          struct tcb_s *nexttcb = this_task();
-
-          /* Update scheduler parameters */
-
-          nxsched_resume_scheduler(nexttcb);
-
-          /* Switch context to the context of the task at the head of the
-           * ready to run list.
-           */
-
-          arm_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs);
-
-          /* arm_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/arch/arm/src/arm/arm_blocktask.c 
b/arch/arm/src/common/arm_blocktask.c
similarity index 99%
rename from arch/arm/src/arm/arm_blocktask.c
rename to arch/arm/src/common/arm_blocktask.c
index af41372..6187b85 100644
--- a/arch/arm/src/arm/arm_blocktask.c
+++ b/arch/arm/src/common/arm_blocktask.c
@@ -1,5 +1,5 @@
 /****************************************************************************
- * arch/arm/src/arm/arm_blocktask.c
+ * arch/arm/src/common/arm_blocktask.c
  *
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
diff --git a/arch/arm/src/armv7-a/arm_releasepending.c 
b/arch/arm/src/common/arm_releasepending.c
similarity index 98%
rename from arch/arm/src/armv7-a/arm_releasepending.c
rename to arch/arm/src/common/arm_releasepending.c
index 7eac444..c4b3646 100644
--- a/arch/arm/src/armv7-a/arm_releasepending.c
+++ b/arch/arm/src/common/arm_releasepending.c
@@ -1,5 +1,5 @@
 /****************************************************************************
- * arch/arm/src/armv7-a/arm_releasepending.c
+ * arch/arm/src/common/arm_releasepending.c
  *
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
diff --git a/arch/arm/src/arm/arm_reprioritizertr.c 
b/arch/arm/src/common/arm_reprioritizertr.c
similarity index 99%
rename from arch/arm/src/arm/arm_reprioritizertr.c
rename to arch/arm/src/common/arm_reprioritizertr.c
index d916322..054f03b 100644
--- a/arch/arm/src/arm/arm_reprioritizertr.c
+++ b/arch/arm/src/common/arm_reprioritizertr.c
@@ -1,5 +1,5 @@
 /****************************************************************************
- * arch/arm/src/arm/arm_reprioritizertr.c
+ * arch/arm/src/common/arm_reprioritizertr.c
  *
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
diff --git a/arch/arm/src/arm/arm_unblocktask.c 
b/arch/arm/src/common/arm_unblocktask.c
similarity index 99%
rename from arch/arm/src/arm/arm_unblocktask.c
rename to arch/arm/src/common/arm_unblocktask.c
index e15f35d..86d96e0 100644
--- a/arch/arm/src/arm/arm_unblocktask.c
+++ b/arch/arm/src/common/arm_unblocktask.c
@@ -1,5 +1,5 @@
 /****************************************************************************
- * arch/arm/src/arm/arm_unblocktask.c
+ * arch/arm/src/common/arm_unblocktask.c
  *
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with