2012-04-14 01:37:52 +02:00
|
|
|
/****************************************************************************
|
2015-02-13 17:30:06 +01:00
|
|
|
* drivers/timers/watchdog.c
|
2012-04-14 01:37:52 +02:00
|
|
|
*
|
2021-03-04 07:10:42 +01:00
|
|
|
* 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
|
2012-04-14 01:37:52 +02:00
|
|
|
*
|
2021-03-04 07:10:42 +01:00
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
2012-04-14 01:37:52 +02:00
|
|
|
*
|
2021-03-04 07:10:42 +01:00
|
|
|
* 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.
|
2012-04-14 01:37:52 +02:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Included Files
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#include <nuttx/config.h>
|
|
|
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <stdbool.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <assert.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <debug.h>
|
|
|
|
|
|
|
|
#include <nuttx/fs/fs.h>
|
|
|
|
#include <nuttx/irq.h>
|
|
|
|
#include <nuttx/kmalloc.h>
|
2019-01-27 17:03:16 +01:00
|
|
|
#include <nuttx/power/pm.h>
|
2020-02-01 08:17:32 +01:00
|
|
|
#include <nuttx/semaphore.h>
|
2019-01-27 17:03:16 +01:00
|
|
|
#include <nuttx/wdog.h>
|
|
|
|
#include <nuttx/wqueue.h>
|
2022-09-18 06:08:13 +02:00
|
|
|
#include <nuttx/timers/oneshot.h>
|
2022-09-18 04:47:19 +02:00
|
|
|
#include <nuttx/timers/timer.h>
|
2015-04-01 20:37:44 +02:00
|
|
|
#include <nuttx/timers/watchdog.h>
|
2012-04-14 01:37:52 +02:00
|
|
|
|
2019-01-27 17:03:16 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Pre-processor Definitions
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-09-15 04:07:44 +02:00
|
|
|
#ifdef CONFIG_WATCHDOG_AUTOMONITOR
|
2022-09-18 04:47:19 +02:00
|
|
|
# define WATCHDOG_AUTOMONITOR_TIMEOUT_MSEC \
|
|
|
|
(CONFIG_WATCHDOG_AUTOMONITOR_TIMEOUT * MSEC_PER_SEC)
|
|
|
|
# if !defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_CAPTURE) && \
|
|
|
|
!defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_IDLE)
|
2022-09-18 14:38:32 +02:00
|
|
|
# if CONFIG_WATCHDOG_AUTOMONITOR_PING_INTERVAL == 0
|
2022-09-18 04:47:19 +02:00
|
|
|
# define WATCHDOG_AUTOMONITOR_PING_INTERVAL \
|
|
|
|
(CONFIG_WATCHDOG_AUTOMONITOR_PING_INTERVAL / 2)
|
|
|
|
# else
|
|
|
|
# define WATCHDOG_AUTOMONITOR_PING_INTERVAL \
|
|
|
|
CONFIG_WATCHDOG_AUTOMONITOR_PING_INTERVAL
|
|
|
|
# endif
|
|
|
|
# define WATCHDOG_AUTOMONITOR_PING_INTERVAL_MSEC \
|
|
|
|
(WATCHDOG_AUTOMONITOR_PING_INTERVAL * MSEC_PER_SEC)
|
|
|
|
# define WATCHDOG_AUTOMONITOR_PING_INTERVAL_TICK \
|
|
|
|
SEC2TICK(WATCHDOG_AUTOMONITOR_PING_INTERVAL)
|
|
|
|
# endif
|
2020-09-15 04:07:44 +02:00
|
|
|
#endif
|
2019-01-27 17:03:16 +01:00
|
|
|
|
2012-04-14 01:37:52 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Private Type Definitions
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/* This structure describes the state of the upper half driver */
|
|
|
|
|
|
|
|
struct watchdog_upperhalf_s
|
|
|
|
{
|
2019-01-27 17:03:16 +01:00
|
|
|
#ifdef CONFIG_WATCHDOG_AUTOMONITOR
|
2022-09-18 06:08:13 +02:00
|
|
|
# if defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_ONESHOT)
|
|
|
|
FAR struct oneshot_lowerhalf_s *oneshot;
|
|
|
|
# elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_TIMER)
|
|
|
|
FAR struct timer_lowerhalf_s *timer;
|
2022-09-18 04:47:19 +02:00
|
|
|
# elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_WDOG)
|
2022-09-18 06:08:13 +02:00
|
|
|
struct wdog_s wdog;
|
2022-09-18 04:47:19 +02:00
|
|
|
# elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_WORKER)
|
2022-09-18 06:08:13 +02:00
|
|
|
struct work_s work;
|
2022-09-18 04:47:19 +02:00
|
|
|
# elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_IDLE)
|
2022-09-18 06:08:13 +02:00
|
|
|
struct pm_callback_s idle;
|
2022-09-18 04:47:19 +02:00
|
|
|
# endif
|
2022-09-18 06:08:13 +02:00
|
|
|
bool monitor;
|
2019-01-27 17:03:16 +01:00
|
|
|
#endif
|
|
|
|
|
2012-04-14 01:37:52 +02:00
|
|
|
uint8_t crefs; /* The number of times the device has been opened */
|
|
|
|
sem_t exclsem; /* Supports mutual exclusion */
|
|
|
|
FAR char *path; /* Registration path */
|
|
|
|
|
|
|
|
/* The contained lower-half driver */
|
2014-04-13 22:32:20 +02:00
|
|
|
|
2012-04-14 01:37:52 +02:00
|
|
|
FAR struct watchdog_lowerhalf_s *lower;
|
|
|
|
};
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Private Function Prototypes
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static int wdog_open(FAR struct file *filep);
|
|
|
|
static int wdog_close(FAR struct file *filep);
|
2012-04-14 15:31:14 +02:00
|
|
|
static ssize_t wdog_read(FAR struct file *filep, FAR char *buffer,
|
|
|
|
size_t buflen);
|
|
|
|
static ssize_t wdog_write(FAR struct file *filep, FAR const char *buffer,
|
|
|
|
size_t buflen);
|
|
|
|
static int wdog_ioctl(FAR struct file *filep, int cmd,
|
|
|
|
unsigned long arg);
|
2012-04-14 01:37:52 +02:00
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Private Data
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static const struct file_operations g_wdogops =
|
|
|
|
{
|
|
|
|
wdog_open, /* open */
|
|
|
|
wdog_close, /* close */
|
|
|
|
wdog_read, /* read */
|
|
|
|
wdog_write, /* write */
|
2019-05-22 02:57:54 +02:00
|
|
|
NULL, /* seek */
|
|
|
|
wdog_ioctl, /* ioctl */
|
|
|
|
NULL /* poll */
|
2022-01-10 15:51:17 +01:00
|
|
|
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
|
|
|
|
, NULL /* unlink */
|
|
|
|
#endif
|
2012-04-14 01:37:52 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Private Functions
|
|
|
|
****************************************************************************/
|
|
|
|
|
2019-01-27 17:03:16 +01:00
|
|
|
#if defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_CAPTURE)
|
|
|
|
static int watchdog_automonitor_capture(int irq, FAR void *context,
|
|
|
|
FAR void *arg)
|
|
|
|
{
|
|
|
|
FAR struct watchdog_upperhalf_s *upper = arg;
|
|
|
|
FAR struct watchdog_lowerhalf_s *lower = upper->lower;
|
|
|
|
|
|
|
|
if (upper->monitor)
|
|
|
|
{
|
|
|
|
lower->ops->keepalive(lower);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2022-09-18 06:08:13 +02:00
|
|
|
#elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_ONESHOT)
|
|
|
|
static void
|
|
|
|
watchdog_automonitor_oneshot(FAR struct oneshot_lowerhalf_s *oneshot,
|
|
|
|
FAR void *arg)
|
|
|
|
{
|
|
|
|
FAR struct watchdog_upperhalf_s *upper = arg;
|
|
|
|
FAR struct watchdog_lowerhalf_s *lower = upper->lower;
|
|
|
|
|
|
|
|
if (upper->monitor)
|
|
|
|
{
|
|
|
|
struct timespec ts =
|
|
|
|
{
|
|
|
|
WATCHDOG_AUTOMONITOR_PING_INTERVAL, 0
|
|
|
|
};
|
|
|
|
|
|
|
|
lower->ops->keepalive(lower);
|
|
|
|
ONESHOT_START(oneshot, watchdog_automonitor_oneshot, upper, &ts);
|
|
|
|
}
|
|
|
|
}
|
2022-09-18 04:47:19 +02:00
|
|
|
#elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_TIMER)
|
|
|
|
static bool watchdog_automonitor_timer(FAR uint32_t *next_interval_us,
|
|
|
|
FAR void *arg)
|
|
|
|
{
|
|
|
|
FAR struct watchdog_upperhalf_s *upper = arg;
|
|
|
|
FAR struct watchdog_lowerhalf_s *lower = upper->lower;
|
|
|
|
|
|
|
|
if (upper->monitor)
|
|
|
|
{
|
|
|
|
lower->ops->keepalive(lower);
|
|
|
|
}
|
|
|
|
|
|
|
|
return upper->monitor;
|
|
|
|
}
|
2022-09-18 04:18:40 +02:00
|
|
|
#elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_WDOG)
|
|
|
|
static void watchdog_automonitor_wdog(wdparm_t arg)
|
2019-01-27 17:03:16 +01:00
|
|
|
{
|
2020-08-09 20:29:35 +02:00
|
|
|
FAR struct watchdog_upperhalf_s *upper = (FAR void *)arg;
|
2019-01-27 17:03:16 +01:00
|
|
|
FAR struct watchdog_lowerhalf_s *lower = upper->lower;
|
|
|
|
|
|
|
|
if (upper->monitor)
|
|
|
|
{
|
|
|
|
lower->ops->keepalive(lower);
|
2022-09-18 04:47:19 +02:00
|
|
|
wd_start(&upper->wdog, WATCHDOG_AUTOMONITOR_PING_INTERVAL_TICK,
|
2022-09-18 04:18:40 +02:00
|
|
|
watchdog_automonitor_wdog, (wdparm_t)upper);
|
2019-01-27 17:03:16 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_WORKER)
|
|
|
|
static void watchdog_automonitor_worker(FAR void *arg)
|
|
|
|
{
|
|
|
|
FAR struct watchdog_upperhalf_s *upper = arg;
|
|
|
|
FAR struct watchdog_lowerhalf_s *lower = upper->lower;
|
|
|
|
|
|
|
|
if (upper->monitor)
|
|
|
|
{
|
|
|
|
lower->ops->keepalive(lower);
|
|
|
|
work_queue(LPWORK, &upper->work, watchdog_automonitor_worker,
|
2022-09-18 04:47:19 +02:00
|
|
|
upper, WATCHDOG_AUTOMONITOR_PING_INTERVAL_TICK);
|
2019-01-27 17:03:16 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_IDLE)
|
|
|
|
static void watchdog_automonitor_idle(FAR struct pm_callback_s *cb,
|
|
|
|
int domain, enum pm_state_e pmstate)
|
|
|
|
{
|
|
|
|
FAR struct watchdog_upperhalf_s *upper = (FAR void *)cb;
|
|
|
|
FAR struct watchdog_lowerhalf_s *lower = upper->lower;
|
|
|
|
|
2022-05-16 22:29:50 +02:00
|
|
|
if (domain == PM_IDLE_DOMAIN &&
|
|
|
|
pmstate != PM_RESTORE && upper->monitor)
|
2019-01-27 17:03:16 +01:00
|
|
|
{
|
|
|
|
lower->ops->keepalive(lower);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_WATCHDOG_AUTOMONITOR
|
2022-09-18 06:08:13 +02:00
|
|
|
# if defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_ONESHOT)
|
|
|
|
static void
|
|
|
|
watchdog_automonitor_start(FAR struct watchdog_upperhalf_s *upper,
|
|
|
|
FAR struct oneshot_lowerhalf_s *oneshot)
|
|
|
|
# elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_TIMER)
|
2022-09-18 04:47:19 +02:00
|
|
|
static void
|
|
|
|
watchdog_automonitor_start(FAR struct watchdog_upperhalf_s *upper,
|
|
|
|
FAR struct timer_lowerhalf_s *timer)
|
|
|
|
# else
|
|
|
|
static void
|
|
|
|
watchdog_automonitor_start(FAR struct watchdog_upperhalf_s *upper)
|
|
|
|
# endif
|
2019-01-27 17:03:16 +01:00
|
|
|
{
|
|
|
|
FAR struct watchdog_lowerhalf_s *lower = upper->lower;
|
|
|
|
|
|
|
|
if (!upper->monitor)
|
|
|
|
{
|
2022-09-18 04:47:19 +02:00
|
|
|
# if defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_CAPTURE)
|
2019-01-27 17:03:16 +01:00
|
|
|
lower->ops->capture(lower, watchdog_automonitor_capture);
|
2022-09-18 06:08:13 +02:00
|
|
|
# elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_ONESHOT)
|
|
|
|
struct timespec ts =
|
|
|
|
{
|
|
|
|
WATCHDOG_AUTOMONITOR_PING_INTERVAL, 0
|
|
|
|
};
|
|
|
|
|
|
|
|
upper->oneshot = oneshot;
|
|
|
|
ONESHOT_START(oneshot, watchdog_automonitor_oneshot, upper, &ts);
|
|
|
|
#elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_TIMER)
|
2022-09-18 04:47:19 +02:00
|
|
|
upper->timer = timer;
|
|
|
|
timer->ops->setcallback(timer, watchdog_automonitor_timer, upper);
|
|
|
|
timer->ops->settimeout(timer, WATCHDOG_AUTOMONITOR_PING_INTERVAL_MSEC);
|
|
|
|
timer->ops->start(timer);
|
|
|
|
# elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_WDOG)
|
|
|
|
wd_start(&upper->wdog, WATCHDOG_AUTOMONITOR_PING_INTERVAL_TICK,
|
2022-09-18 04:18:40 +02:00
|
|
|
watchdog_automonitor_wdog, (wdparm_t)upper);
|
2022-09-18 04:47:19 +02:00
|
|
|
# elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_WORKER)
|
2019-01-27 17:03:16 +01:00
|
|
|
work_queue(LPWORK, &upper->work, watchdog_automonitor_worker,
|
2022-09-18 04:47:19 +02:00
|
|
|
upper, WATCHDOG_AUTOMONITOR_PING_INTERVAL_TICK);
|
|
|
|
# elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_IDLE)
|
2019-01-27 17:03:16 +01:00
|
|
|
upper->idle.notify = watchdog_automonitor_idle;
|
|
|
|
pm_register(&upper->idle);
|
2022-09-18 04:47:19 +02:00
|
|
|
# endif
|
2022-09-18 06:08:13 +02:00
|
|
|
upper->monitor = true;
|
2019-01-27 17:03:16 +01:00
|
|
|
if (lower->ops->settimeout)
|
|
|
|
{
|
|
|
|
lower->ops->settimeout(lower, WATCHDOG_AUTOMONITOR_TIMEOUT_MSEC);
|
|
|
|
}
|
|
|
|
|
|
|
|
lower->ops->start(lower);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void watchdog_automonitor_stop(FAR struct watchdog_upperhalf_s *upper)
|
|
|
|
{
|
|
|
|
FAR struct watchdog_lowerhalf_s *lower = upper->lower;
|
|
|
|
|
|
|
|
if (upper->monitor)
|
|
|
|
{
|
|
|
|
upper->monitor = false;
|
|
|
|
lower->ops->stop(lower);
|
2022-09-18 04:47:19 +02:00
|
|
|
# if defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_CAPTURE)
|
2019-01-27 17:03:16 +01:00
|
|
|
lower->ops->capture(lower, NULL);
|
2022-09-18 06:08:13 +02:00
|
|
|
# elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_ONESHOT)
|
|
|
|
ONESHOT_CANCEL(upper->oneshot, NULL);
|
2022-09-18 04:47:19 +02:00
|
|
|
# elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_TIMER)
|
|
|
|
upper->timer->ops->stop(upper->timer);
|
|
|
|
# elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_WDOG)
|
2020-08-04 12:31:31 +02:00
|
|
|
wd_cancel(&upper->wdog);
|
2022-09-18 04:47:19 +02:00
|
|
|
# elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_WORKER)
|
2019-01-27 17:03:16 +01:00
|
|
|
work_cancel(LPWORK, &upper->work);
|
2022-09-18 04:47:19 +02:00
|
|
|
# elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_IDLE)
|
2019-01-27 17:03:16 +01:00
|
|
|
pm_unregister(&upper->idle);
|
2022-09-18 04:47:19 +02:00
|
|
|
# endif
|
2019-01-27 17:03:16 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/****************************************************************************
|
2012-04-14 01:37:52 +02:00
|
|
|
* Name: wdog_open
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* This function is called whenever the watchdog timer device is opened.
|
|
|
|
*
|
2019-01-27 17:03:16 +01:00
|
|
|
****************************************************************************/
|
2012-04-14 01:37:52 +02:00
|
|
|
|
|
|
|
static int wdog_open(FAR struct file *filep)
|
|
|
|
{
|
|
|
|
FAR struct inode *inode = filep->f_inode;
|
|
|
|
FAR struct watchdog_upperhalf_s *upper = inode->i_private;
|
|
|
|
uint8_t tmp;
|
|
|
|
int ret;
|
|
|
|
|
2016-06-11 19:59:51 +02:00
|
|
|
wdinfo("crefs: %d\n", upper->crefs);
|
2012-04-14 01:37:52 +02:00
|
|
|
|
|
|
|
/* Get exclusive access to the device structures */
|
|
|
|
|
2017-10-04 23:22:27 +02:00
|
|
|
ret = nxsem_wait(&upper->exclsem);
|
2012-04-14 01:37:52 +02:00
|
|
|
if (ret < 0)
|
|
|
|
{
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Increment the count of references to the device. If this the first
|
|
|
|
* time that the driver has been opened for this device, then initialize
|
|
|
|
* the device.
|
|
|
|
*/
|
|
|
|
|
|
|
|
tmp = upper->crefs + 1;
|
|
|
|
if (tmp == 0)
|
|
|
|
{
|
|
|
|
/* More than 255 opens; uint8_t overflows to zero */
|
|
|
|
|
|
|
|
ret = -EMFILE;
|
|
|
|
goto errout_with_sem;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Save the new open count */
|
|
|
|
|
|
|
|
upper->crefs = tmp;
|
|
|
|
ret = OK;
|
|
|
|
|
|
|
|
errout_with_sem:
|
2017-10-03 23:35:24 +02:00
|
|
|
nxsem_post(&upper->exclsem);
|
2014-04-13 22:32:20 +02:00
|
|
|
|
2012-04-14 01:37:52 +02:00
|
|
|
errout:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-01-27 17:03:16 +01:00
|
|
|
/****************************************************************************
|
2012-04-14 01:37:52 +02:00
|
|
|
* Name: wdog_close
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* This function is called when the watchdog timer device is closed.
|
|
|
|
*
|
2019-01-27 17:03:16 +01:00
|
|
|
****************************************************************************/
|
2012-04-14 01:37:52 +02:00
|
|
|
|
|
|
|
static int wdog_close(FAR struct file *filep)
|
|
|
|
{
|
|
|
|
FAR struct inode *inode = filep->f_inode;
|
|
|
|
FAR struct watchdog_upperhalf_s *upper = inode->i_private;
|
|
|
|
int ret;
|
|
|
|
|
2016-06-11 19:59:51 +02:00
|
|
|
wdinfo("crefs: %d\n", upper->crefs);
|
2012-04-14 01:37:52 +02:00
|
|
|
|
|
|
|
/* Get exclusive access to the device structures */
|
|
|
|
|
2017-10-04 23:22:27 +02:00
|
|
|
ret = nxsem_wait(&upper->exclsem);
|
2012-04-14 01:37:52 +02:00
|
|
|
if (ret < 0)
|
|
|
|
{
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Decrement the references to the driver. If the reference count will
|
|
|
|
* decrement to 0, then uninitialize the driver.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (upper->crefs > 0)
|
|
|
|
{
|
|
|
|
upper->crefs--;
|
|
|
|
}
|
|
|
|
|
2017-10-03 23:35:24 +02:00
|
|
|
nxsem_post(&upper->exclsem);
|
2012-04-14 01:37:52 +02:00
|
|
|
ret = OK;
|
2014-04-13 22:32:20 +02:00
|
|
|
|
2012-04-14 01:37:52 +02:00
|
|
|
errout:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-01-27 17:03:16 +01:00
|
|
|
/****************************************************************************
|
2012-04-14 01:37:52 +02:00
|
|
|
* Name: wdog_read
|
|
|
|
*
|
|
|
|
* Description:
|
2014-04-06 17:02:02 +02:00
|
|
|
* A dummy read method. This is provided only to satisfy the VFS layer.
|
2012-04-14 01:37:52 +02:00
|
|
|
*
|
2019-01-27 17:03:16 +01:00
|
|
|
****************************************************************************/
|
2012-04-14 01:37:52 +02:00
|
|
|
|
2019-01-27 17:03:16 +01:00
|
|
|
static ssize_t wdog_read(FAR struct file *filep, FAR char *buffer,
|
|
|
|
size_t buflen)
|
2012-04-14 01:37:52 +02:00
|
|
|
{
|
|
|
|
/* Return zero -- usually meaning end-of-file */
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-01-27 17:03:16 +01:00
|
|
|
/****************************************************************************
|
2012-04-14 01:37:52 +02:00
|
|
|
* Name: wdog_write
|
|
|
|
*
|
|
|
|
* Description:
|
2014-04-06 17:02:02 +02:00
|
|
|
* A dummy write method. This is provided only to satisfy the VFS layer.
|
2012-04-14 01:37:52 +02:00
|
|
|
*
|
2019-01-27 17:03:16 +01:00
|
|
|
****************************************************************************/
|
2012-04-14 01:37:52 +02:00
|
|
|
|
2019-01-27 17:03:16 +01:00
|
|
|
static ssize_t wdog_write(FAR struct file *filep, FAR const char *buffer,
|
|
|
|
size_t buflen)
|
2012-04-14 01:37:52 +02:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-01-27 17:03:16 +01:00
|
|
|
/****************************************************************************
|
2012-04-14 01:37:52 +02:00
|
|
|
* Name: wdog_ioctl
|
|
|
|
*
|
|
|
|
* Description:
|
2019-01-27 17:03:16 +01:00
|
|
|
* The standard ioctl method. This is where ALL of the watchdog timer
|
|
|
|
* work is done.
|
2014-04-13 22:32:20 +02:00
|
|
|
*
|
2019-01-27 17:03:16 +01:00
|
|
|
****************************************************************************/
|
2012-04-14 01:37:52 +02:00
|
|
|
|
|
|
|
static int wdog_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
|
|
|
|
{
|
|
|
|
FAR struct inode *inode = filep->f_inode;
|
2017-05-15 15:20:32 +02:00
|
|
|
FAR struct watchdog_upperhalf_s *upper;
|
|
|
|
FAR struct watchdog_lowerhalf_s *lower;
|
2012-04-14 01:37:52 +02:00
|
|
|
int ret;
|
|
|
|
|
2016-06-11 19:59:51 +02:00
|
|
|
wdinfo("cmd: %d arg: %ld\n", cmd, arg);
|
2017-05-15 15:20:32 +02:00
|
|
|
upper = inode->i_private;
|
|
|
|
DEBUGASSERT(upper != NULL);
|
|
|
|
lower = upper->lower;
|
|
|
|
DEBUGASSERT(lower != NULL);
|
2012-04-14 01:37:52 +02:00
|
|
|
|
|
|
|
/* Get exclusive access to the device structures */
|
|
|
|
|
2017-10-04 23:22:27 +02:00
|
|
|
ret = nxsem_wait(&upper->exclsem);
|
2012-04-14 01:37:52 +02:00
|
|
|
if (ret < 0)
|
|
|
|
{
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Handle built-in ioctl commands */
|
|
|
|
|
|
|
|
switch (cmd)
|
|
|
|
{
|
|
|
|
/* cmd: WDIOC_START
|
|
|
|
* Description: Start the watchdog timer
|
|
|
|
* Argument: Ignored
|
|
|
|
*/
|
|
|
|
|
|
|
|
case WDIOC_START:
|
|
|
|
{
|
2019-01-27 17:03:16 +01:00
|
|
|
#ifdef CONFIG_WATCHDOG_AUTOMONITOR
|
|
|
|
watchdog_automonitor_stop(upper);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Start the watchdog timer, resetting the time to the current
|
|
|
|
* timeout
|
|
|
|
*/
|
2012-04-14 01:37:52 +02:00
|
|
|
|
|
|
|
DEBUGASSERT(lower->ops->start); /* Required */
|
|
|
|
ret = lower->ops->start(lower);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* cmd: WDIOC_STOP
|
|
|
|
* Description: Stop the watchdog timer
|
|
|
|
* Argument: Ignored
|
|
|
|
*/
|
|
|
|
|
|
|
|
case WDIOC_STOP:
|
|
|
|
{
|
|
|
|
/* Stop the watchdog timer */
|
|
|
|
|
|
|
|
DEBUGASSERT(lower->ops->stop); /* Required */
|
|
|
|
ret = lower->ops->stop(lower);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* cmd: WDIOC_GETSTATUS
|
2014-04-06 17:02:02 +02:00
|
|
|
* Description: Get the status of the watchdog timer.
|
2012-04-14 01:37:52 +02:00
|
|
|
* Argument: A writeable pointer to struct watchdog_status_s.
|
|
|
|
*/
|
|
|
|
|
|
|
|
case WDIOC_GETSTATUS:
|
|
|
|
{
|
|
|
|
FAR struct watchdog_status_s *status;
|
|
|
|
|
|
|
|
/* Get the current watchdog timer status */
|
|
|
|
|
|
|
|
if (lower->ops->getstatus) /* Optional */
|
|
|
|
{
|
|
|
|
status = (FAR struct watchdog_status_s *)((uintptr_t)arg);
|
|
|
|
if (status)
|
|
|
|
{
|
|
|
|
ret = lower->ops->getstatus(lower, status);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ret = -ENOSYS;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* cmd: WDIOC_SETTIMEOUT
|
|
|
|
* Description: Reset the watchdog timeout to this value
|
|
|
|
* Argument: A 32-bit timeout value in milliseconds.
|
|
|
|
*/
|
|
|
|
|
|
|
|
case WDIOC_SETTIMEOUT:
|
|
|
|
{
|
|
|
|
/* Set a new timeout value (and reset the watchdog timer) */
|
|
|
|
|
|
|
|
if (lower->ops->settimeout) /* Optional */
|
|
|
|
{
|
|
|
|
ret = lower->ops->settimeout(lower, (uint32_t)arg);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ret = -ENOSYS;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* cmd: WDIOC_CAPTURE
|
|
|
|
* Description: Do not reset. Instead, called this handler.
|
|
|
|
* Argument: A pointer to struct watchdog_capture_s.
|
|
|
|
*/
|
|
|
|
|
|
|
|
case WDIOC_CAPTURE:
|
|
|
|
{
|
|
|
|
FAR struct watchdog_capture_s *capture;
|
|
|
|
|
|
|
|
/* Don't reset on watchdog timer timeout; instead, call this user
|
|
|
|
* provider timeout handler. NOTE: Providing handler==NULL will
|
|
|
|
* restore the reset behavior.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (lower->ops->capture) /* Optional */
|
|
|
|
{
|
|
|
|
capture = (FAR struct watchdog_capture_s *)((uintptr_t)arg);
|
|
|
|
if (capture)
|
|
|
|
{
|
|
|
|
capture->oldhandler =
|
|
|
|
lower->ops->capture(lower, capture->newhandler);
|
|
|
|
ret = OK;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ret = -ENOSYS;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* cmd: WDIOC_KEEPALIVE
|
|
|
|
* Description: Reset the watchdog timer ("ping", "pet the dog")
|
|
|
|
* Argument: Argument: Ignored
|
|
|
|
*/
|
|
|
|
|
|
|
|
case WDIOC_KEEPALIVE:
|
|
|
|
{
|
2019-01-27 17:03:16 +01:00
|
|
|
/* Reset the watchdog timer to the current timeout value, prevent
|
|
|
|
* any imminent watchdog timeouts. This is sometimes referred as
|
2012-04-14 01:37:52 +02:00
|
|
|
* "pinging" the watchdog timer or "petting the dog".
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (lower->ops->keepalive) /* Optional */
|
|
|
|
{
|
|
|
|
ret = lower->ops->keepalive(lower);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ret = -ENOSYS;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2019-01-27 17:03:16 +01:00
|
|
|
/* Any unrecognized IOCTL commands might be platform-specific ioctl
|
|
|
|
* commands
|
|
|
|
*/
|
2012-04-14 01:37:52 +02:00
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
2016-06-11 19:59:51 +02:00
|
|
|
wdinfo("Forwarding unrecognized cmd: %d arg: %ld\n", cmd, arg);
|
2012-04-14 01:37:52 +02:00
|
|
|
|
|
|
|
/* An ioctl commands that are not recognized by the "upper-half"
|
|
|
|
* driver are forwarded to the lower half driver through this
|
|
|
|
* method.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (lower->ops->ioctl) /* Optional */
|
|
|
|
{
|
|
|
|
ret = lower->ops->ioctl(lower, cmd, arg);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-06-06 19:21:44 +02:00
|
|
|
ret = -ENOTTY;
|
2012-04-14 01:37:52 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2017-10-03 23:35:24 +02:00
|
|
|
nxsem_post(&upper->exclsem);
|
2012-04-14 01:37:52 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Public Functions
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: watchdog_register
|
|
|
|
*
|
|
|
|
* Description:
|
2019-01-27 17:03:16 +01:00
|
|
|
* This function binds an instance of a "lower half" watchdog driver with
|
|
|
|
* the "upper half" watchdog device and registers that device so that can
|
|
|
|
* be usedby application code.
|
2012-04-14 01:37:52 +02:00
|
|
|
*
|
|
|
|
* When this function is called, the "lower half" driver should be in the
|
|
|
|
* disabled state (as if the stop() method had already been called).
|
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Input Parameters:
|
2012-04-14 01:37:52 +02:00
|
|
|
* dev path - The full path to the driver to be registers in the NuttX
|
2019-01-27 17:03:16 +01:00
|
|
|
* pseudo-filesystem. The recommended convention is to name all
|
|
|
|
* watchdogdrivers as "/dev/watchdog0", "/dev/watchdog1", etc. where
|
|
|
|
* the driverpath differs only in the "minor" number at the end of the
|
|
|
|
* device name.
|
2012-04-14 01:37:52 +02:00
|
|
|
* lower - A pointer to an instance of lower half watchdog driver. This
|
|
|
|
* instance is bound to the watchdog driver and must persists as long as
|
|
|
|
* the driver persists.
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* On success, a non-NULL handle is returned to the caller. In the event
|
|
|
|
* of any failure, a NULL value is returned.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2022-09-18 06:08:13 +02:00
|
|
|
#if defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_ONESHOT)
|
|
|
|
FAR void *watchdog_register(FAR const char *path,
|
|
|
|
FAR struct watchdog_lowerhalf_s *lower,
|
|
|
|
FAR struct oneshot_lowerhalf_s *oneshot)
|
|
|
|
#elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_TIMER)
|
2022-09-18 04:47:19 +02:00
|
|
|
FAR void *watchdog_register(FAR const char *path,
|
|
|
|
FAR struct watchdog_lowerhalf_s *lower,
|
|
|
|
FAR struct timer_lowerhalf_s *timer)
|
|
|
|
#else
|
2012-04-14 01:37:52 +02:00
|
|
|
FAR void *watchdog_register(FAR const char *path,
|
|
|
|
FAR struct watchdog_lowerhalf_s *lower)
|
2022-09-18 04:47:19 +02:00
|
|
|
#endif
|
2012-04-14 01:37:52 +02:00
|
|
|
{
|
|
|
|
FAR struct watchdog_upperhalf_s *upper;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
DEBUGASSERT(path && lower);
|
2016-06-11 19:59:51 +02:00
|
|
|
wdinfo("Entry: path=%s\n", path);
|
2012-04-14 01:37:52 +02:00
|
|
|
|
|
|
|
/* Allocate the upper-half data structure */
|
|
|
|
|
|
|
|
upper = (FAR struct watchdog_upperhalf_s *)
|
2014-09-01 01:34:44 +02:00
|
|
|
kmm_zalloc(sizeof(struct watchdog_upperhalf_s));
|
2012-04-14 01:37:52 +02:00
|
|
|
if (!upper)
|
|
|
|
{
|
2016-06-11 23:50:49 +02:00
|
|
|
wderr("Upper half allocation failed\n");
|
2012-04-14 01:37:52 +02:00
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize the watchdog timer device structure (it was already zeroed
|
2014-09-01 01:34:44 +02:00
|
|
|
* by kmm_zalloc()).
|
2012-04-14 01:37:52 +02:00
|
|
|
*/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
nxsem_init(&upper->exclsem, 0, 1);
|
2012-04-14 01:37:52 +02:00
|
|
|
upper->lower = lower;
|
|
|
|
|
|
|
|
/* Copy the registration path */
|
|
|
|
|
|
|
|
upper->path = strdup(path);
|
|
|
|
if (!upper->path)
|
|
|
|
{
|
2016-06-11 23:50:49 +02:00
|
|
|
wderr("Path allocation failed\n");
|
2012-04-14 01:37:52 +02:00
|
|
|
goto errout_with_upper;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Register the watchdog timer device */
|
|
|
|
|
|
|
|
ret = register_driver(path, &g_wdogops, 0666, upper);
|
|
|
|
if (ret < 0)
|
|
|
|
{
|
2016-06-11 23:50:49 +02:00
|
|
|
wderr("register_driver failed: %d\n", ret);
|
2012-04-14 01:37:52 +02:00
|
|
|
goto errout_with_path;
|
|
|
|
}
|
|
|
|
|
2022-09-18 06:08:13 +02:00
|
|
|
#if defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_ONESHOT)
|
|
|
|
watchdog_automonitor_start(upper, oneshot);
|
|
|
|
#elif defined(CONFIG_WATCHDOG_AUTOMONITOR_BY_TIMER)
|
2022-09-18 04:47:19 +02:00
|
|
|
watchdog_automonitor_start(upper, timer);
|
|
|
|
#elif defined(CONFIG_WATCHDOG_AUTOMONITOR)
|
2019-01-27 17:03:16 +01:00
|
|
|
watchdog_automonitor_start(upper);
|
|
|
|
#endif
|
|
|
|
|
2012-04-14 01:37:52 +02:00
|
|
|
return (FAR void *)upper;
|
|
|
|
|
|
|
|
errout_with_path:
|
2014-09-01 01:04:02 +02:00
|
|
|
kmm_free(upper->path);
|
2012-04-14 01:37:52 +02:00
|
|
|
|
|
|
|
errout_with_upper:
|
2017-10-03 23:35:24 +02:00
|
|
|
nxsem_destroy(&upper->exclsem);
|
2014-09-01 01:04:02 +02:00
|
|
|
kmm_free(upper);
|
2012-04-14 01:37:52 +02:00
|
|
|
|
|
|
|
errout:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: watchdog_unregister
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* This function can be called to disable and unregister the watchdog
|
|
|
|
* device driver.
|
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Input Parameters:
|
2012-04-14 01:37:52 +02:00
|
|
|
* handle - This is the handle that was returned by watchdog_register()
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* None
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
void watchdog_unregister(FAR void *handle)
|
|
|
|
{
|
|
|
|
FAR struct watchdog_upperhalf_s *upper;
|
|
|
|
FAR struct watchdog_lowerhalf_s *lower;
|
|
|
|
|
|
|
|
/* Recover the pointer to the upper-half driver state */
|
|
|
|
|
|
|
|
upper = (FAR struct watchdog_upperhalf_s *)handle;
|
2017-05-15 15:20:32 +02:00
|
|
|
DEBUGASSERT(upper != NULL);
|
2012-04-14 01:37:52 +02:00
|
|
|
lower = upper->lower;
|
2017-05-15 15:20:32 +02:00
|
|
|
DEBUGASSERT(lower != NULL);
|
2012-04-14 01:37:52 +02:00
|
|
|
|
2016-06-11 19:59:51 +02:00
|
|
|
wdinfo("Unregistering: %s\n", upper->path);
|
2012-04-16 19:20:36 +02:00
|
|
|
|
2019-01-27 17:03:16 +01:00
|
|
|
#ifdef CONFIG_WATCHDOG_AUTOMONITOR
|
|
|
|
watchdog_automonitor_stop(upper);
|
|
|
|
#endif
|
|
|
|
|
2012-04-14 01:37:52 +02:00
|
|
|
/* Disable the watchdog timer */
|
|
|
|
|
|
|
|
DEBUGASSERT(lower->ops->stop); /* Required */
|
2020-01-02 17:49:34 +01:00
|
|
|
lower->ops->stop(lower);
|
2012-04-14 01:37:52 +02:00
|
|
|
|
|
|
|
/* Unregister the watchdog timer device */
|
|
|
|
|
2020-01-02 17:49:34 +01:00
|
|
|
unregister_driver(upper->path);
|
2012-04-14 01:37:52 +02:00
|
|
|
|
|
|
|
/* Then free all of the driver resources */
|
|
|
|
|
2014-09-01 01:04:02 +02:00
|
|
|
kmm_free(upper->path);
|
2017-10-03 23:35:24 +02:00
|
|
|
nxsem_destroy(&upper->exclsem);
|
2014-09-01 01:04:02 +02:00
|
|
|
kmm_free(upper);
|
2012-04-14 01:37:52 +02:00
|
|
|
}
|