sched/wdog: merge wdog_periods_s into wdog_s

include/nuttx/wdog.h

@@ -88,13 +88,8 @@ struct wdog_s
   FAR void          *picbase;    /* PIC base address */
 #endif
   clock_t            expired;    /* Timer associated with the absoulute time */
-};
-
-struct wdog_period_s
-{
-  struct wdog_s      wdog;       /* Watchdog */
   clock_t            period;     /* Period time in ticks */
-  wdentry_t          func;       /* Wrapped function to execute when delay expires */
+  wdentry_t          pfunc;      /* Period Function to execute when delay expires */
 };
 
 /****************************************************************************
@@ -311,7 +306,7 @@ static inline int wd_start_realtime(FAR struct wdog_s *wdog,
  *
  ****************************************************************************/
 
-int wd_start_period(FAR struct wdog_period_s *wdog, sclock_t delay,
+int wd_start_period(FAR struct wdog_s *wdog, sclock_t delay,
                     clock_t period, wdentry_t wdentry, wdparm_t arg);
 
 /****************************************************************************
@@ -332,32 +327,6 @@ int wd_start_period(FAR struct wdog_period_s *wdog, sclock_t delay,
 
 int wd_cancel(FAR struct wdog_s *wdog);
 
-/****************************************************************************
- * Name: wd_cancel_period
- *
- * Description:
- *   This function cancels a currently running periodic watchdog timer.
- *
- * Input Parameters:
- *   wdog_period - Pointer of the periodic watchdog.
- *
- * Returned Value:
- *   Zero (OK) is returned on success;  A negated errno value is returned to
- *   indicate the nature of any failure.
- *
- ****************************************************************************/
-
-static inline int wd_cancel_period(FAR struct wdog_period_s *wdog_period)
-{
-  if (!wdog_period)
-    {
-      return -EINVAL;
-    }
-
-  wdog_period->period = 0;
-  return wd_cancel(&wdog_period->wdog);
-}
-
 /****************************************************************************
  * Name: wd_gettime
  *

include/nuttx/wqueue.h

@@ -257,7 +257,6 @@ struct work_s
       clock_t qtime;             /* Time work queued */
     } s;
     struct wdog_s timer;         /* Delay expiry timer */
-    struct wdog_period_s ptimer; /* Period expiry timer */
   } u;
   worker_t  worker;              /* Work callback */
   FAR void *arg;                 /* Callback argument */

sched/wdog/wd_cancel.c

@@ -65,6 +65,8 @@ int wd_cancel(FAR struct wdog_s *wdog)
 
   flags = spin_lock_irqsave(&g_wdspinlock);
 
+  wdog->period = 0;
+
   /* Make sure that the watchdog is valid and still active. */
 
   if (wdog == NULL || !WDOG_ISACTIVE(wdog))

sched/wdog/wd_start.c

@@ -82,9 +82,6 @@
 
 #endif
 
-#define wdparm_to_ptr(type, arg) ((type)(uintptr_t)arg)
-#define ptr_to_wdparm(ptr)       wdparm_to_ptr(wdparm_t, ptr)
-
 /****************************************************************************
  * Private Data
  ****************************************************************************/
@@ -98,7 +95,7 @@ static unsigned int g_wdtimernested;
  ****************************************************************************/
 
 /****************************************************************************
- * Name: wdentry_period
+ * Name: wd_period_callback
  *
  * Description:
  *   Periodic watchdog timer callback function.
@@ -111,23 +108,20 @@ static unsigned int g_wdtimernested;
  *
  ****************************************************************************/
 
-static void wdentry_period(wdparm_t arg)
+static void wd_period_callback(wdparm_t arg)
 {
-  FAR struct wdog_period_s *wdperiod;
-
-  wdperiod = wdparm_to_ptr(FAR struct wdog_period_s *, arg);
+  FAR struct wdog_s *wdog = ((FAR struct wdog_s *)(uintptr_t)arg);
 
-  wdperiod->func(wdperiod->wdog.arg);
+  wdog->pfunc(wdog->arg);
 
   /* Since we set `ticks++` at `wd_start_abstick`,
    * we need to use `expired - 1` here to avoid time drift.
    */
 
-  if (wdperiod->period != 0)
+  if (wdog->period != 0)
     {
-      wd_start_abstick(&wdperiod->wdog,
-                       wdperiod->wdog.expired + wdperiod->period - 1,
-                       wdentry_period, wdperiod->wdog.arg);
+      wd_start_abstick(wdog, wdog->expired + wdog->period - 1,
+                       wd_period_callback, wdog->arg);
     }
 }
 
@@ -187,8 +181,7 @@ static inline_function void wd_expiration(clock_t ticks)
       func = wdog->func;
       wdog->func = NULL;
 
-      arg = func != wdentry_period ? wdog->arg : ptr_to_wdparm(
-            list_container_of(wdog, struct wdog_period_s, wdog));
+      arg = wdog->arg;
 
       /* Execute the watchdog function */
 
@@ -460,18 +453,18 @@ int wd_start(FAR struct wdog_s *wdog, sclock_t delay,
  *
  ****************************************************************************/
 
-int wd_start_period(FAR struct wdog_period_s *wdog, sclock_t delay,
+int wd_start_period(FAR struct wdog_s *wdog, sclock_t delay,
                     clock_t period, wdentry_t wdentry, wdparm_t arg)
 {
   if (!wdog || !period || !wdentry)
     {
       return -EINVAL;
     }
 
-  wdog->func   = wdentry;
+  wdog->pfunc  = wdentry;
   wdog->period = period;
 
-  return wd_start(&wdog->wdog, delay, wdentry_period, arg);
+  return wd_start(wdog, delay, wd_period_callback, arg);
 }
 
 /****************************************************************************

sched/wqueue/kwork_queue.c

@@ -195,7 +195,7 @@ int work_queue_period_wq(FAR struct kwork_wqueue_s *wqueue,
     }
   else
     {
-      ret = wd_start_period(&work->u.ptimer, delay, period,
+      ret = wd_start_period(&work->u.timer, delay, period,
                             work_timer_expiry, (wdparm_t)work);
     }