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; lower = upper->lower; DEBUGASSERT(upper && lower); wdinfo("Unregistering: %s\n", upper->path); /* Disable the watchdog timer */ DEBUGASSERT(lower->ops->stop); /* Required */ (void)lower->ops->stop(lower); /* Unregister the watchdog timer device */ (void)unregister_driver(upper->path); /* Then free all of the driver resources */ kmm_free(upper->path); sem_destroy(&upper->exclsem); kmm_free(upper); }
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; wdinfo("crefs: %d\n", upper->crefs); /* Get exclusive access to the device structures */ ret = sem_wait(&upper->exclsem); if (ret < 0) { ret = -get_errno(); 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--; } sem_post(&upper->exclsem); ret = OK; errout: return ret; }
static int wdog_daemon(int argc, char *argv[]) { FAR struct file filestruct; int ret; /* Open the watchdog device for reading */ wdinfo("Opening.\n"); ret = file_open(&filestruct, CONFIG_WATCHDOG_DEVPATH, O_RDONLY); if (ret < 0) { wderr("ERROR: open %s failed: %d\n", CONFIG_WATCHDOG_DEVPATH, ret); goto errout; } /* Start the watchdog timer. */ wdinfo("Starting.\n"); ret = file_ioctl(&filestruct, WDIOC_START, 0); if (ret < 0) { wderr("ERROR: ioctl(WDIOC_START) failed: %d\n", errno); goto errout_with_dev; } nxsig_usleep(200); while(1) { nxsig_usleep((CONFIG_WDT_THREAD_INTERVAL)*1000); wdinfo("ping\n"); ret = file_ioctl(&filestruct, WDIOC_KEEPALIVE, 0); if (ret < 0) { wderr("ERROR: ioctl(WDIOC_KEEPALIVE) failed: %d\n", errno); goto errout_with_dev; } } errout_with_dev: file_close(&filestruct); errout: return ret; }
FAR void *watchdog_register(FAR const char *path, FAR struct watchdog_lowerhalf_s *lower) { FAR struct watchdog_upperhalf_s *upper; int ret; DEBUGASSERT(path && lower); wdinfo("Entry: path=%s\n", path); /* Allocate the upper-half data structure */ upper = (FAR struct watchdog_upperhalf_s *) kmm_zalloc(sizeof(struct watchdog_upperhalf_s)); if (!upper) { wderr("Upper half allocation failed\n"); goto errout; } /* Initialize the watchdog timer device structure (it was already zeroed * by kmm_zalloc()). */ sem_init(&upper->exclsem, 0, 1); upper->lower = lower; /* Copy the registration path */ upper->path = strdup(path); if (!upper->path) { wderr("Path allocation failed\n"); goto errout_with_upper; } /* Register the watchdog timer device */ ret = register_driver(path, &g_wdogops, 0666, upper); if (ret < 0) { wderr("register_driver failed: %d\n", ret); goto errout_with_path; } return (FAR void *)upper; errout_with_path: kmm_free(upper->path); errout_with_upper: sem_destroy(&upper->exclsem); kmm_free(upper); errout: return NULL; }
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; wdinfo("crefs: %d\n", upper->crefs); /* Get exclusive access to the device structures */ ret = sem_wait(&upper->exclsem); if (ret < 0) { ret = -get_errno(); 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: sem_post(&upper->exclsem); errout: return ret; }
int sam_watchdog_initialize(void) { #if (defined(CONFIG_SAM34_WDT) && !defined(CONFIG_WDT_DISABLE_ON_RESET)) FAR struct file filestruct; int ret; /* Initialize tha register the watchdog timer device */ wdinfo("Initializing Watchdog driver...\n"); sam_wdtinitialize(CONFIG_WATCHDOG_DEVPATH); /* Open the watchdog device */ wdinfo("Opening.\n"); ret = file_open(&filestruct, CONFIG_WATCHDOG_DEVPATH, O_RDONLY); if (ret < 0) { wderr("ERROR: open %s failed: %d\n", CONFIG_WATCHDOG_DEVPATH, ret); goto errout; } /* Set the watchdog timeout */ wdinfo("Timeout = %d.\n", CONFIG_WDT_TIMEOUT); ret = file_ioctl(&filestruct, WDIOC_SETTIMEOUT, (unsigned long)CONFIG_WDT_TIMEOUT); if (ret < 0) { wderr("ERROR: ioctl(WDIOC_SETTIMEOUT) failed: %d\n", errno); goto errout_with_dev; } /* Set the watchdog minimum time */ wdinfo("MinTime = %d.\n", CONFIG_WDT_MINTIME); ret = file_ioctl(&filestruct, WDIOC_MINTIME, (unsigned long)CONFIG_WDT_MINTIME); if (ret < 0) { wderr("ERROR: ioctl(WDIOC_MINTIME) failed: %d\n", errno); goto errout_with_dev; } /* Start Kicker task */ #if defined(CONFIG_WDT_THREAD) sched_lock(); int taskid = kthread_create(CONFIG_WDT_THREAD_NAME, CONFIG_WDT_THREAD_PRIORITY, CONFIG_WDT_THREAD_STACKSIZE, (main_t)wdog_daemon, (FAR char * const *)NULL); DEBUGASSERT(taskid > 0); UNUSED(taskid); sched_unlock(); #endif return OK; errout_with_dev: file_close(&filestruct); errout: return ret; #else return -ENODEV; #endif }
static int wdog_ioctl(FAR struct file *filep, int cmd, unsigned long arg) { FAR struct inode *inode = filep->f_inode; FAR struct watchdog_upperhalf_s *upper = inode->i_private; FAR struct watchdog_lowerhalf_s *lower = upper->lower; int ret; wdinfo("cmd: %d arg: %ld\n", cmd, arg); DEBUGASSERT(upper && lower); /* Get exclusive access to the device structures */ ret = sem_wait(&upper->exclsem); 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: { /* Start the watchdog timer, resetting the time to the current timeout */ 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 * Description: Get the status of the watchdog timer. * 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: { /* Reset the watchdog timer to the current timeout value, prevent any * imminent watchdog timeouts. This is sometimes referred as * "pinging" the watchdog timer or "petting the dog". */ if (lower->ops->keepalive) /* Optional */ { ret = lower->ops->keepalive(lower); } else { ret = -ENOSYS; } } break; /* Any unrecognized IOCTL commands might be platform-specific ioctl commands */ default: { wdinfo("Forwarding unrecognized cmd: %d arg: %ld\n", cmd, arg); /* 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 { ret = -ENOSYS; } } break; } sem_post(&upper->exclsem); return ret; }