SAMA5: Add option to support oneshot timer without free-running timer. Add oneshot lower half driver.

arch/arm/src/sama5/Kconfig

@@ -3866,7 +3866,6 @@ endif # SAMA5_TC2
 
 config SAMA5_ONESHOT
 	bool "TC one-shot wrapper"
-	depends on SAMA5_FREERUN
 	default n if !SCHED_TICKLESS
 	default y if SCHED_TICKLESS
 	---help---

arch/arm/src/sama5/Make.defs

@@ -1,7 +1,7 @@
 ############################################################################
 # arch/arm/sama5/Make.defs
 #
-#   Copyright (C) 2013-2014 Gregory Nutt. All rights reserved.
+#   Copyright (C) 2013-2014, 2016 Gregory Nutt. All rights reserved.
 #   Author: Gregory Nutt <gnutt@nuttx.org>
 #
 # Redistribution and use in source and binary forms, with or without
@@ -292,7 +292,7 @@ endif
 ifeq ($(CONFIG_SAMA5_HAVE_TC),y)
 CHIP_CSRCS += sam_tc.c
 ifeq ($(CONFIG_SAMA5_ONESHOT),y)
-CHIP_CSRCS += sam_oneshot.c
+CHIP_CSRCS += sam_oneshot.c sam_oneshot_lowerhalf.c
 endif
 ifeq ($(CONFIG_SAMA5_FREERUN),y)
 CHIP_CSRCS += sam_freerun.c

arch/arm/src/sama5/sam_freerun.c

@@ -60,27 +60,12 @@
 
 #include "sam_freerun.h"
 
-#ifdef CONFIG_SAMA5_ONESHOT
+#ifdef CONFIG_SAMA5_FREERUN
-
-/****************************************************************************
- * Pre-processor Definitions
- ****************************************************************************/
-
-/****************************************************************************
- * Private Types
- ****************************************************************************/
-
-/****************************************************************************
- * Private Function Prototypes
- ****************************************************************************/
-
-/****************************************************************************
- * Private Data
- ****************************************************************************/
 
 /****************************************************************************
  * Private Functions
  ****************************************************************************/
+
 /****************************************************************************
  * Name: sam_freerun_handler
  *
@@ -333,4 +318,4 @@ int sam_freerun_uninitialize(struct sam_freerun_s *freerun)
   return OK;
 }
 
-#endif /* CONFIG_SAMA5_ONESHOT */
+#endif /* CONFIG_SAMA5_FREERUN */

arch/arm/src/sama5/sam_oneshot.c

@@ -63,22 +63,6 @@
 
 #ifdef CONFIG_SAMA5_ONESHOT
 
-/****************************************************************************
- * Pre-processor Definitions
- ****************************************************************************/
-
-/****************************************************************************
- * Private Types
- ****************************************************************************/
-
-/****************************************************************************
- * Private Function Prototypes
- ****************************************************************************/
-
-/****************************************************************************
- * Private Data
- ****************************************************************************/
-
 /****************************************************************************
  * Private Functions
  ****************************************************************************/
@@ -128,7 +112,9 @@ static void sam_oneshot_handler(TC_HANDLE tch, void *arg, uint32_t sr)
   oneshot->handler     = NULL;
   oneshot_arg          = (void *)oneshot->arg;
   oneshot->arg         = NULL;
+#ifdef CONFIG_SAMA5_FREERUN
   oneshot->start_count = 0;
+#endif
 
   oneshot_handler(oneshot_arg);
 }
@@ -229,7 +215,10 @@ int sam_oneshot_initialize(struct sam_oneshot_s *oneshot, int chan,
   oneshot->running     = false;
   oneshot->handler     = NULL;
   oneshot->arg         = NULL;
+#ifdef CONFIG_SAMA5_FREERUN
   oneshot->start_count = 0;
+#endif
+
   return OK;
 }
 
@@ -253,8 +242,10 @@ int sam_oneshot_initialize(struct sam_oneshot_s *oneshot, int chan,
  *
  ****************************************************************************/
 
-int sam_oneshot_start(struct sam_oneshot_s *oneshot, struct sam_freerun_s *freerun,
+int sam_oneshot_start(struct sam_oneshot_s *oneshot,
-                      oneshot_handler_t handler, void *arg, const struct timespec *ts)
+                      struct sam_freerun_s *freerun,
+                      oneshot_handler_t handler, void *arg,
+                      const struct timespec *ts)
 {
   uint64_t usec;
   uint64_t regval;
@@ -311,6 +302,7 @@ int sam_oneshot_start(struct sam_oneshot_s *oneshot, struct sam_freerun_s *freer
 
   sam_tc_start(oneshot->tch);
 
+#ifdef CONFIG_SAMA5_FREERUN
   /* The function sam_tc_start() starts the timer/counter by setting the
    * bits TC_CCR_CLKEN and TC_CCR_SWTRG in the channel control register.
    * The first one enables the timer/counter the latter performs an
@@ -329,7 +321,11 @@ int sam_oneshot_start(struct sam_oneshot_s *oneshot, struct sam_freerun_s *freer
    * vanishes at least if compiled with no optimisation.
    */
 
+  if (freerun != NULL)
+    {
       oneshot->start_count = sam_tc_getcounter(freerun->tch);
+    }
+#endif
 
   /* Enable interrupts.  We should get the callback when the interrupt
    * occurs.
@@ -365,8 +361,8 @@ int sam_oneshot_start(struct sam_oneshot_s *oneshot, struct sam_freerun_s *freer
  *
  ****************************************************************************/
 
-int sam_oneshot_cancel(struct sam_oneshot_s *oneshot, struct sam_freerun_s *freerun,
+int sam_oneshot_cancel(struct sam_oneshot_s *oneshot,
-                       struct timespec *ts)
+                       struct sam_freerun_s *freerun, struct timespec *ts)
 {
   irqstate_t flags;
   uint64_t usec;
@@ -407,16 +403,19 @@ int sam_oneshot_cancel(struct sam_oneshot_s *oneshot, struct sam_freerun_s *free
   count = sam_tc_getcounter(oneshot->tch);
   rc    = sam_tc_getregister(oneshot->tch, TC_REGC);
 
+#ifdef CONFIG_SAMA5_FREERUN
   /* In the case the timer/counter was canceled very short after its start,
    * the counter register can hold the wrong value (the value of the last
    * run). To prevent this the counter value is set to zero if not at
    * least on tick passed since the start of the timer/counter.
    */
 
-  if (count > 0 && sam_tc_getcounter(freerun->tch) == oneshot->start_count)
+  if (count > 0 && freerun != NULL &&
+      sam_tc_getcounter(freerun->tch) == oneshot->start_count)
     {
       count = 0;
     }
+#endif
 
   /* Now we can disable the interrupt and stop the timer. */
 

arch/arm/src/sama5/sam_oneshot.h

@@ -46,7 +46,6 @@
 #include <time.h>
 
 #include "sam_tc.h"
-#include "sam_freerun.h"
 
 #ifdef CONFIG_SAMA5_ONESHOT
 
@@ -83,11 +82,13 @@ struct sam_oneshot_s
   volatile oneshot_handler_t handler; /* Oneshot expiration callback */
   volatile void *arg;                 /* The argument that will accompany
                                        * the callback */
+#ifdef CONFIG_SAMA5_FREERUN
   volatile uint32_t start_count;      /* Stores the value of the freerun counter,
                                        * at each start of the onshot timer. Is neccesary
                                        * to find out if the onshot counter was updated
                                        * correctly at the time of the call to
                                        * sam_oneshot_cancel or not. */
+#endif
 };
 
 /****************************************************************************
@@ -153,8 +154,11 @@ int sam_oneshot_initialize(struct sam_oneshot_s *oneshot, int chan,
  *
  ****************************************************************************/
 
-int sam_oneshot_start(struct sam_oneshot_s *oneshot, struct sam_freerun_s *freerun,
+struct sam_freerun_s;
-                      oneshot_handler_t handler, void *arg, const struct timespec *ts);
+int sam_oneshot_start(struct sam_oneshot_s *oneshot,
+                      struct sam_freerun_s *freerun,
+                      oneshot_handler_t handler, void *arg,
+                      const struct timespec *ts);
 
 /****************************************************************************
  * Name: sam_oneshot_cancel
@@ -183,8 +187,9 @@ int sam_oneshot_start(struct sam_oneshot_s *oneshot, struct sam_freerun_s *freer
  *
  ****************************************************************************/
 
-int sam_oneshot_cancel(struct sam_oneshot_s *oneshot, struct sam_freerun_s *freerun,
+struct sam_freerun_s;
-                       struct timespec *ts);
+int sam_oneshot_cancel(struct sam_oneshot_s *oneshot,
+                       struct sam_freerun_s *freerun, struct timespec *ts);
 
 #undef EXTERN
 #ifdef __cplusplus

arch/arm/src/sama5/sam_oneshot_lowerhalf.c

@@ -0,0 +1,335 @@
+/****************************************************************************
+ *  arch/arm/src/sam/sam_oneshot_lowerhalf.c
+ *
+ *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Authors: Gregory Nutt <gnutt@nuttx.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+
+#include <stdint.h>
+#include <time.h>
+#include <assert.h>
+#include <errno.h>
+#include <debug.h>
+
+#include <nuttx/irq.h>
+#include <nuttx/kmalloc.h>
+#include <nuttx/timers/oneshot.h>
+
+#include "sam_oneshot.h"
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+/* This structure describes the state of the oneshot timer lower-half driver */
+
+struct sam_oneshot_lowerhalf_s
+{
+  /* This is the part of the lower half driver that is visible to the upper-
+   * half client of the driver.  This must be the first thing in this
+   * structure so that pointers to struct oneshot_lowerhalf_s are cast
+   * compatible to struct sam_oneshot_lowerhalf_s and vice versa.
+   */
+
+  struct oneshot_lowerhalf_s lh;  /* Common lower-half driver fields */
+
+  /* Private lower half data follows */
+
+  struct sam_oneshot_s oneshot; /* STM32-specific oneshot state */
+  oneshot_callback_t callback;    /* internal handler that receives callback */
+  FAR void *arg;                  /* Argument that is passed to the handler */
+};
+
+/****************************************************************************
+ * Private Function Prototypes
+ ****************************************************************************/
+
+static void sam_oneshot_handler(void *arg);
+
+static int sam_max_delay(FAR struct oneshot_lowerhalf_s *lower,
+                         FAR uint64_t *usec);
+static int sam_start(FAR struct oneshot_lowerhalf_s *lower,
+                     oneshot_callback_t callback, FAR void *arg,
+                     FAR const struct timespec *ts);
+static int sam_cancel(FAR struct oneshot_lowerhalf_s *lower,
+                      FAR struct timespec *ts);
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/* Lower half operations */
+
+static const struct oneshot_operations_s g_oneshot_ops =
+{
+  .max_delay = sam_max_delay,
+  .start     = sam_start,
+  .cancel    = sam_cancel,
+};
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: sam_oneshot_handler
+ *
+ * Description:
+ *   Timer expiration handler
+ *
+ * Input Parameters:
+ *   arg - Should be the same argument provided when sam_oneshot_start()
+ *         was called.
+ *
+ * Returned Value:
+ *   None
+ *
+ ****************************************************************************/
+
+static void sam_oneshot_handler(void *arg)
+{
+  FAR struct sam_oneshot_lowerhalf_s *priv =
+    (FAR struct sam_oneshot_lowerhalf_s *)arg;
+  oneshot_callback_t callback;
+  FAR void *cbarg;
+
+  DEBUGASSERT(priv != NULL);
+
+  /* Perhaps the callback was nullified in a race condition with
+   * sam_cancel?
+   */
+
+  if (priv->callback)
+  {
+    /* Sample and nullify BEFORE executing callback (in case the callback
+     * restarts the oneshot).
+     */
+
+    callback       = priv->callback;
+    cbarg          = priv->arg;
+    priv->callback = NULL;
+    priv->arg      = NULL;
+
+    /* Then perform the callback */
+
+    callback(&priv->lh, cbarg);
+  }
+}
+
+/****************************************************************************
+ * Name: sam_max_delay
+ *
+ * Description:
+ *   Determine the maximum delay of the one-shot timer (in microseconds)
+ *
+ * Input Parameters:
+ *   lower   An instance of the lower-half oneshot state structure.  This
+ *           structure must have been previously initialized via a call to
+ *           oneshot_initialize();
+ *   usec    The user-provided location in which to return the maxumum delay
+ *           in microseconds.
+ *
+ * Returned Value:
+ *   Zero (OK) is returned on success; a negated errno value is returned
+ *   on failure.
+ *
+ ****************************************************************************/
+
+static int sam_max_delay(FAR struct oneshot_lowerhalf_s *lower,
+                           FAR uint64_t *usec)
+{
+  DEBUGASSERT(priv != NULL && usec != NULL);
+
+#warning Missing logic
+ *usec = UINT64_MAX;
+  return -ENOSYS;
+}
+
+/****************************************************************************
+ * Name: sam_start
+ *
+ * Description:
+ *   Start the oneshot timer
+ *
+ * Input Parameters:
+ *   lower   An instance of the lower-half oneshot state structure.  This
+ *           structure must have been previously initialized via a call to
+ *           oneshot_initialize();
+ *   handler The function to call when when the oneshot timer expires.
+ *   arg     An opaque argument that will accompany the callback.
+ *   ts      Provides the duration of the one shot timer.
+ *
+ * Returned Value:
+ *   Zero (OK) is returned on success; a negated errno value is returned
+ *   on failure.
+ *
+ ****************************************************************************/
+
+static int sam_start(FAR struct oneshot_lowerhalf_s *lower,
+                     oneshot_callback_t callback, FAR void *arg,
+                     FAR const struct timespec *ts)
+{
+  FAR struct sam_oneshot_lowerhalf_s *priv =
+    (FAR struct sam_oneshot_lowerhalf_s *)lower;
+  irqstate_t flags;
+  int ret;
+
+  DEBUGASSERT(priv != NULL);
+
+  /* Save the callback information and start the timer */
+
+  flags          = enter_critical_section();
+  priv->callback = callback;
+  priv->arg      = arg;
+  ret            = sam_oneshot_start(&priv->oneshot, NULL,
+                                       sam_oneshot_handler, priv, ts);
+  leave_critical_section(flags);
+
+  if (ret < 0)
+    {
+      tmrerr("ERROR: sam_oneshot_start failed: %d\n", flags);
+    }
+
+  return ret;
+}
+
+/****************************************************************************
+ * Name: sam_cancel
+ *
+ * Description:
+ *   Cancel the oneshot timer and return the time remaining on the timer.
+ *
+ *   NOTE: This function may execute at a high rate with no timer running (as
+ *   when pre-emption is enabled and disabled).
+ *
+ * Input Parameters:
+ *   lower   Caller allocated instance of the oneshot state structure.  This
+ *           structure must have been previously initialized via a call to
+ *           oneshot_initialize();
+ *   ts      The location in which to return the time remaining on the
+ *           oneshot timer.  A time of zero is returned if the timer is
+ *           not running.
+ *
+ * Returned Value:
+ *   Zero (OK) is returned on success.  A call to up_timer_cancel() when
+ *   the timer is not active should also return success; a negated errno
+ *   value is returned on any failure.
+ *
+ ****************************************************************************/
+
+static int sam_cancel(FAR struct oneshot_lowerhalf_s *lower,
+                      FAR struct timespec *ts)
+{
+  FAR struct sam_oneshot_lowerhalf_s *priv =
+    (FAR struct sam_oneshot_lowerhalf_s *)lower;
+  irqstate_t flags;
+  int ret;
+
+  DEBUGASSERT(priv != NULL);
+
+  /* Cancel the timer */
+
+  flags          = enter_critical_section();
+  ret            = sam_oneshot_cancel(&priv->oneshot, NULL, ts);
+  priv->callback = NULL;
+  priv->arg      = NULL;
+  leave_critical_section(flags);
+
+  if (ret < 0)
+    {
+      tmrerr("ERROR: sam_oneshot_cancel failed: %d\n", flags);
+    }
+
+  return ret;
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: oneshot_initialize
+ *
+ * Description:
+ *   Initialize the oneshot timer and return a oneshot lower half driver
+ *   instance.
+ *
+ * Input Parameters:
+ *   chan       Timer counter channel to be used.
+ *   resolution The required resolution of the timer in units of
+ *              microseconds.  NOTE that the range is restricted to the
+ *              range of uint16_t (excluding zero).
+ *
+ * Returned Value:
+ *   On success, a non-NULL instance of the oneshot lower-half driver is
+ *   returned.  NULL is return on any failure.
+ *
+ ****************************************************************************/
+
+FAR struct oneshot_lowerhalf_s *oneshot_initialize(int chan,
+                                                   uint16_t resolution)
+{
+  FAR struct sam_oneshot_lowerhalf_s *priv;
+  int ret;
+
+  /* Allocate an instance of the lower half driver */
+
+  priv = (FAR struct sam_oneshot_lowerhalf_s *)
+    kmm_zalloc(sizeof(struct sam_oneshot_lowerhalf_s));
+
+  if (priv == NULL)
+    {
+      tmrerr("ERROR: Failed to initialized state structure\n");
+      return NULL;
+    }
+
+  /* Initialize the lower-half driver structure */
+
+  priv->lh.ops = &g_oneshot_ops;
+
+  /* Initialize the contained STM32 oneshot timer */
+
+  ret = sam_oneshot_initialize(&priv->oneshot, chan, resolution);
+  if (ret < 0)
+    {
+      tmrerr("ERROR: Failed to initialized state structure\n");
+      kmm_free(priv);
+      return NULL;
+    }
+
+  return &priv->lh;
+}

arch/arm/src/samv7/sam_oneshot_lowerhalf.c

@@ -174,7 +174,7 @@ static int sam_max_delay(FAR struct oneshot_lowerhalf_s *lower,
   FAR struct sam_oneshot_lowerhalf_s *priv =
     (FAR struct sam_oneshot_lowerhalf_s *)lower;
 
-  DEBUGASSERT(priv != NULL);
+  DEBUGASSERT(priv != NULL && usec != NULL);
   return sam_oneshot_max_delay(&priv->oneshot, usec);
 }
 

arch/arm/src/stm32/stm32_oneshot_lowerhalf.c

@@ -174,7 +174,7 @@ static int stm32_max_delay(FAR struct oneshot_lowerhalf_s *lower,
   FAR struct stm32_oneshot_lowerhalf_s *priv =
     (FAR struct stm32_oneshot_lowerhalf_s *)lower;
 
-  DEBUGASSERT(priv != NULL);
+  DEBUGASSERT(priv != NULL && usec != NULL);
   return stm32_oneshot_max_delay(&priv->oneshot, usec);
 }