From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from skprod3.natinst.com ([130.164.80.24]:57076 "EHLO ni.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S935372AbcJ1Hwe (ORCPT ); Fri, 28 Oct 2016 03:52:34 -0400 From: Hui Chun Ong To: , , CC: , , , , Hui Chun Ong Subject: [RESEND PATCH] watchdog: ni7018_wdt: Add NIC7018 watchdog driver Date: Fri, 28 Oct 2016 15:51:07 +0800 Message-ID: <1477641067-5004-1-git-send-email-hui.chun.ong@ni.com> MIME-Version: 1.0 Content-Type: text/plain Sender: linux-watchdog-owner@vger.kernel.org List-Id: linux-watchdog@vger.kernel.org Add support for the watchdog timer on PXI Embedded Controller. Signed-off-by: Hui Chun Ong --- Documentation/watchdog/watchdog-parameters.txt | 5 + drivers/watchdog/Kconfig | 11 + drivers/watchdog/Makefile | 1 + drivers/watchdog/ni7018_wdt.c | 506 +++++++++++++++++++++++++ 4 files changed, 523 insertions(+) create mode 100644 drivers/watchdog/ni7018_wdt.c diff --git a/Documentation/watchdog/watchdog-parameters.txt b/Documentation/watchdog/watchdog-parameters.txt index a8d3642..25dbfa2 100644 --- a/Documentation/watchdog/watchdog-parameters.txt +++ b/Documentation/watchdog/watchdog-parameters.txt @@ -204,6 +204,11 @@ mv64x60_wdt: nowayout: Watchdog cannot be stopped once started (default=kernel config parameter) ------------------------------------------------- +ni7018_wdt: +timeout: Initial watchdog timeout in seconds (0 +#include +#include +#include +#include +#include +#include + +#define LOCK 0xA5 +#define UNLOCK 0x5A + +#define WDT_CTRL_RESET_EN BIT(7) +#define WDT_CTRL_TRIG_POLARITY BIT(4) +#define WDT_CTRL_TRIG 0x0F + +#define WDT_RELOAD_PORT_EN BIT(7) +#define WDT_RELOAD_TRIG_POLARITY BIT(6) +#define WDT_RELOAD_TRIG 0x0F +#define WDT_MIN_TRIG_NUM 0 +#define WDT_MAX_TRIG_NUM 8 + +#define WDT_CTRL 1 +#define WDT_RELOAD_CTRL 2 +#define WDT_PRESET_PRESCALE 4 +#define WDT_REG_LOCK 5 +#define WDT_COUNT 6 +#define WDT_RELOAD_PORT 7 + +#define WDT_IO_SIZE 8 + +#define WDT_MIN_TIMEOUT 1 +#define WDT_MAX_TIMEOUT 464 +#define WDT_DEFAULT_TIMEOUT 80 + +#define WDT_MAX_COUNTER 15 + +static unsigned int timeout; +module_param(timeout, uint, 0); +MODULE_PARM_DESC(timeout, + "Watchdog timeout in seconds. (default=" + __MODULE_STRING(WDT_DEFAULT_TIMEOUT) ")"); + +static int nowayout = WATCHDOG_NOWAYOUT; +module_param(nowayout, int, S_IRUGO); +MODULE_PARM_DESC(nowayout, + "Watchdog cannot be stopped once started. (default=" + __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); + +struct ni7018_wdt { + struct device *dev; + u16 io_base; + u32 period_ms; + struct mutex lock; + struct watchdog_device wdd; +}; + +struct ni7018_config { + u32 period_ms; + u8 divider; +}; + +static const struct ni7018_config ni7018_configs[] = { + { 125, 3 }, + { 2000, 4 }, + { 32000, 5 }, +}; + +static inline u32 ni7018_timeout_ms(u32 period_ms, u8 counter) +{ + return period_ms * counter - period_ms / 2; +} + +static const struct ni7018_config *ni7018_get_config(u32 timeout_ms, + u8 *counter) +{ + u32 delta, i, best_delta = U32_MAX; + const struct ni7018_config *config, *best_config = NULL; + u8 count; + + for (i = 0; i < ARRAY_SIZE(ni7018_configs); i++) { + config = &ni7018_configs[i]; + + count = DIV_ROUND_UP(timeout_ms + config->period_ms / 2, + config->period_ms); + + if (count > WDT_MAX_COUNTER) + continue; + + delta = ni7018_timeout_ms(config->period_ms, count) - + timeout_ms; + + if (delta < best_delta) { + best_delta = delta; + best_config = config; + *counter = count; + } + } + return best_config; +} + +static int ni7018_set_timeout(struct watchdog_device *wdd, + unsigned int timeout) +{ + struct ni7018_wdt *wdt = watchdog_get_drvdata(wdd); + const struct ni7018_config *config; + u8 counter; + + config = ni7018_get_config(timeout * 1000, &counter); + if (!config) + return -EINVAL; + + mutex_lock(&wdt->lock); + + outb(counter << 4 | config->divider, + wdt->io_base + WDT_PRESET_PRESCALE); + + wdd->timeout = ni7018_timeout_ms(config->period_ms, counter) / 1000; + wdt->period_ms = config->period_ms; + + mutex_unlock(&wdt->lock); + return 0; +} + +static int ni7018_start(struct watchdog_device *wdd) +{ + struct ni7018_wdt *wdt = watchdog_get_drvdata(wdd); + u8 control; + + ni7018_set_timeout(wdd, wdd->timeout); + + mutex_lock(&wdt->lock); + + control = inb(wdt->io_base + WDT_RELOAD_CTRL); + outb(control | WDT_RELOAD_PORT_EN, wdt->io_base + WDT_RELOAD_CTRL); + + outb(1, wdt->io_base + WDT_RELOAD_PORT); + + control = inb(wdt->io_base + WDT_CTRL); + outb(control | WDT_CTRL_RESET_EN, wdt->io_base + WDT_CTRL); + + mutex_unlock(&wdt->lock); + return 0; +} + +static int ni7018_stop(struct watchdog_device *wdd) +{ + struct ni7018_wdt *wdt = watchdog_get_drvdata(wdd); + + mutex_lock(&wdt->lock); + + outb(0, wdt->io_base + WDT_CTRL); + outb(0, wdt->io_base + WDT_RELOAD_CTRL); + outb(0xF0, wdt->io_base + WDT_PRESET_PRESCALE); + + mutex_unlock(&wdt->lock); + return 0; +} + +static int ni7018_ping(struct watchdog_device *wdd) +{ + struct ni7018_wdt *wdt = watchdog_get_drvdata(wdd); + + mutex_lock(&wdt->lock); + + outb(1, wdt->io_base + WDT_RELOAD_PORT); + + mutex_unlock(&wdt->lock); + return 0; +} + +static unsigned int ni7018_get_timeleft(struct watchdog_device *wdd) +{ + struct ni7018_wdt *wdt = watchdog_get_drvdata(wdd); + u8 count; + + mutex_lock(&wdt->lock); + + count = inb(wdt->io_base + WDT_COUNT) & 0xF; + + mutex_unlock(&wdt->lock); + + if (!count) + return 0; + + return ni7018_timeout_ms(wdt->period_ms, count) / 1000; +} + +static acpi_status +ni7018_resources(struct acpi_resource *res, void *data) +{ + struct ni7018_wdt *wdt = data; + u16 io_size; + + switch (res->type) { + case ACPI_RESOURCE_TYPE_IO: + if (wdt->io_base != 0) { + dev_err(wdt->dev, "too many IO resources\n"); + return AE_ERROR; + } + + wdt->io_base = res->data.io.minimum; + io_size = res->data.io.address_length; + + if (io_size < WDT_IO_SIZE) { + dev_err(wdt->dev, "memory region too small\n"); + return AE_ERROR; + } + + if (!devm_request_region(wdt->dev, wdt->io_base, io_size, + KBUILD_MODNAME)) { + dev_err(wdt->dev, "failed to get memory region\n"); + return AE_ERROR; + } + + return AE_OK; + + default: + /* Ignore unsupported resources */ + return AE_OK; + } +} + +static const struct watchdog_info ni7018_wdd_info = { + .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE, + .identity = "NI 7018 Watchdog", +}; + +static const struct watchdog_ops ni7018_wdd_ops = { + .owner = THIS_MODULE, + .start = ni7018_start, + .stop = ni7018_stop, + .ping = ni7018_ping, + .set_timeout = ni7018_set_timeout, + .get_timeleft = ni7018_get_timeleft, +}; + +struct ni7018_attr { + struct device_attribute dev_attr; + u8 offset; + u8 bit; +}; +#define to_ni7018_attr(_attr) \ + container_of((_attr), struct ni7018_attr, dev_attr) + +static ssize_t wdt_attr_show(struct device *dev, + struct device_attribute *da, + char *buf) +{ + struct watchdog_device *wdd = dev_get_drvdata(dev); + struct ni7018_wdt *wdt = watchdog_get_drvdata(wdd); + struct ni7018_attr *attr = to_ni7018_attr(da); + u8 control; + size_t ret; + + mutex_lock(&wdt->lock); + + control = inb(wdt->io_base + attr->offset); + + mutex_unlock(&wdt->lock); + + ret = sprintf(buf, "%u\n", !!(control & attr->bit)); + return ret; +} + +static ssize_t wdt_attr_store(struct device *dev, + struct device_attribute *da, + const char *buf, + size_t size) +{ + struct watchdog_device *wdd = dev_get_drvdata(dev); + struct ni7018_wdt *wdt = watchdog_get_drvdata(wdd); + struct ni7018_attr *attr = to_ni7018_attr(da); + unsigned long val; + u8 control; + + int ret = kstrtoul(buf, 10, &val); + + if (ret) + return ret; + + if (val < 0 || val > 1) + return -EINVAL; + + mutex_lock(&wdt->lock); + + control = inb(wdt->io_base + attr->offset); + if (val) + outb(control | attr->bit, wdt->io_base + attr->offset); + else + outb(control & ~attr->bit, wdt->io_base + attr->offset); + + mutex_unlock(&wdt->lock); + return size; +} + +#define WDT_ATTR(_name, _offset, _bit) \ + struct ni7018_attr dev_attr_##_name = { \ + .offset = _offset, \ + .bit = _bit, \ + .dev_attr = \ + __ATTR(_name, S_IWUSR | S_IRUGO, \ + wdt_attr_show, wdt_attr_store), \ + } + +static WDT_ATTR(enable_reset, WDT_CTRL, WDT_CTRL_RESET_EN); +static WDT_ATTR(enable_soft_ping, WDT_RELOAD_CTRL, WDT_RELOAD_PORT_EN); +static WDT_ATTR(trigger_polarity, WDT_CTRL, WDT_CTRL_TRIG_POLARITY); +static WDT_ATTR(keepalive_trigger_polarity, WDT_RELOAD_CTRL, + WDT_RELOAD_TRIG_POLARITY); + +static ssize_t wdt_trig_show(struct device *dev, + struct device_attribute *da, + char *buf) +{ + struct watchdog_device *wdd = dev_get_drvdata(dev); + struct ni7018_wdt *wdt = watchdog_get_drvdata(wdd); + struct ni7018_attr *attr = to_ni7018_attr(da); + u8 control; + size_t ret; + + mutex_lock(&wdt->lock); + + control = inb(wdt->io_base + attr->offset); + + mutex_unlock(&wdt->lock); + + if (control & attr->bit) + ret = sprintf(buf, "trig%u\n", (control & attr->bit) - 1); + else + ret = sprintf(buf, "none\n"); + + return ret; +} + +static ssize_t wdt_trig_store(struct device *dev, + struct device_attribute *da, + const char *buf, + size_t size) +{ + struct watchdog_device *wdd = dev_get_drvdata(dev); + struct ni7018_wdt *wdt = watchdog_get_drvdata(wdd); + struct ni7018_attr *attr = to_ni7018_attr(da); + unsigned long val; + u8 control; + int ret; + + if (!strncmp(buf, "trig", 4)) { + ret = kstrtoul(buf + 4, 10, &val); + if (ret) + return ret; + + if (val < WDT_MIN_TRIG_NUM || val > WDT_MAX_TRIG_NUM) + return -EINVAL; + + mutex_lock(&wdt->lock); + + control = inb(wdt->io_base + attr->offset); + outb((control & ~attr->bit) | (val + 1), + wdt->io_base + attr->offset); + + mutex_unlock(&wdt->lock); + + } else if (!strncmp(buf, "none", 4)) { + mutex_lock(&wdt->lock); + + control = inb(wdt->io_base + attr->offset); + outb(control & ~attr->bit, wdt->io_base + attr->offset); + + mutex_unlock(&wdt->lock); + + } else { + return -EINVAL; + } + + return size; +} + +#define WDT_TRIG_ATTR(_name, _offset, _bit) \ + struct ni7018_attr dev_attr_##_name = { \ + .offset = _offset, \ + .bit = _bit, \ + .dev_attr = \ + __ATTR(_name, S_IWUSR | S_IRUGO, \ + wdt_trig_show, wdt_trig_store), \ + } + +static WDT_TRIG_ATTR(trigger, WDT_CTRL, WDT_CTRL_TRIG); +static WDT_TRIG_ATTR(keepalive_trigger, WDT_RELOAD_CTRL, WDT_RELOAD_TRIG); + +static struct attribute *ni7018_wdt_attrs[] = { + &dev_attr_enable_reset.dev_attr.attr, + &dev_attr_enable_soft_ping.dev_attr.attr, + &dev_attr_trigger_polarity.dev_attr.attr, + &dev_attr_keepalive_trigger_polarity.dev_attr.attr, + &dev_attr_trigger.dev_attr.attr, + &dev_attr_keepalive_trigger.dev_attr.attr, + NULL +}; +ATTRIBUTE_GROUPS(ni7018_wdt); + +static int ni7018_add(struct acpi_device *device) +{ + struct device *dev = &device->dev; + struct watchdog_device *wdd; + struct ni7018_wdt *wdt; + acpi_status status; + int ret; + + wdt = devm_kzalloc(dev, sizeof(*wdt), GFP_KERNEL); + if (!wdt) + return -ENOMEM; + + device->driver_data = wdt; + wdt->dev = dev; + + status = acpi_walk_resources(device->handle, METHOD_NAME__CRS, + ni7018_resources, wdt); + + if (ACPI_FAILURE(status) || wdt->io_base == 0) { + dev_err(dev, "failed to get resources\n"); + return -ENODEV; + } + + wdd = &wdt->wdd; + wdd->info = &ni7018_wdd_info; + wdd->ops = &ni7018_wdd_ops; + wdd->min_timeout = WDT_MIN_TIMEOUT; + wdd->max_timeout = WDT_MAX_TIMEOUT; + wdd->timeout = WDT_DEFAULT_TIMEOUT; + wdd->parent = dev; + wdd->groups = ni7018_wdt_groups; + + mutex_init(&wdt->lock); + watchdog_set_drvdata(wdd, wdt); + watchdog_set_nowayout(wdd, nowayout); + + ret = watchdog_init_timeout(wdd, timeout, dev); + if (ret) + dev_err(dev, "unable to set timeout value, using default\n"); + + /* Unlock WDT register */ + outb(UNLOCK, wdt->io_base + WDT_REG_LOCK); + + ret = watchdog_register_device(wdd); + if (ret) { + dev_err(dev, "failed to register watchdog\n"); + goto err_out; + } + + dev_dbg(dev, "io_base=0x%04X, timeout=%d, nowayout=%d\n", + wdt->io_base, timeout, nowayout); + return 0; + +err_out: + mutex_destroy(&wdt->lock); + return ret; +} + +static int ni7018_remove(struct acpi_device *device) +{ + struct ni7018_wdt *wdt = acpi_driver_data(device); + + ni7018_stop(&wdt->wdd); + watchdog_unregister_device(&wdt->wdd); + + /* Lock WDT register */ + outb(LOCK, wdt->io_base + WDT_REG_LOCK); + + mutex_destroy(&wdt->lock); + return 0; +} + +static const struct acpi_device_id ni7018_device_ids[] = { + {"NIC7018", 0}, + {"", 0}, +}; +MODULE_DEVICE_TABLE(acpi, ni7018_device_ids); + +static struct acpi_driver ni7018_acpi_driver = { + .name = KBUILD_MODNAME, + .ids = ni7018_device_ids, + .ops = { + .add = ni7018_add, + .remove = ni7018_remove, + }, +}; + +module_acpi_driver(ni7018_acpi_driver); + +MODULE_DESCRIPTION("NI 7018 Watchdog"); +MODULE_AUTHOR("Hui Chun Ong "); +MODULE_LICENSE("GPL v2"); -- 2.7.4