Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Kevin Strasser | 2259 | 98.78% | 1 | 11.11% |
Guenter Roeck | 13 | 0.57% | 1 | 11.11% |
Arnd Bergmann | 7 | 0.31% | 1 | 11.11% |
Jingoo Han | 3 | 0.13% | 2 | 22.22% |
Thomas Gleixner | 2 | 0.09% | 1 | 11.11% |
Julia Lawall | 1 | 0.04% | 1 | 11.11% |
gundberg | 1 | 0.04% | 1 | 11.11% |
Bhumika Goyal | 1 | 0.04% | 1 | 11.11% |
Total | 2287 | 9 |
// SPDX-License-Identifier: GPL-2.0-only /* * Kontron PLD watchdog driver * * Copyright (c) 2010-2013 Kontron Europe GmbH * Author: Michael Brunner <michael.brunner@kontron.com> * * Note: From the PLD watchdog point of view timeout and pretimeout are * defined differently than in the kernel. * First the pretimeout stage runs out before the timeout stage gets * active. * * Kernel/API: P-----| pretimeout * |-----------------------T timeout * Watchdog: |-----------------P pretimeout_stage * |-----T timeout_stage */ #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/uaccess.h> #include <linux/watchdog.h> #include <linux/platform_device.h> #include <linux/mfd/kempld.h> #define KEMPLD_WDT_STAGE_TIMEOUT(x) (0x1b + (x) * 4) #define KEMPLD_WDT_STAGE_CFG(x) (0x18 + (x)) #define STAGE_CFG_GET_PRESCALER(x) (((x) & 0x30) >> 4) #define STAGE_CFG_SET_PRESCALER(x) (((x) & 0x3) << 4) #define STAGE_CFG_PRESCALER_MASK 0x30 #define STAGE_CFG_ACTION_MASK 0x7 #define STAGE_CFG_ASSERT (1 << 3) #define KEMPLD_WDT_MAX_STAGES 2 #define KEMPLD_WDT_KICK 0x16 #define KEMPLD_WDT_CFG 0x17 #define KEMPLD_WDT_CFG_ENABLE 0x10 #define KEMPLD_WDT_CFG_ENABLE_LOCK 0x8 #define KEMPLD_WDT_CFG_GLOBAL_LOCK 0x80 enum { ACTION_NONE = 0, ACTION_RESET, ACTION_NMI, ACTION_SMI, ACTION_SCI, ACTION_DELAY, }; enum { STAGE_TIMEOUT = 0, STAGE_PRETIMEOUT, }; enum { PRESCALER_21 = 0, PRESCALER_17, PRESCALER_12, }; static const u32 kempld_prescaler[] = { [PRESCALER_21] = (1 << 21) - 1, [PRESCALER_17] = (1 << 17) - 1, [PRESCALER_12] = (1 << 12) - 1, 0, }; struct kempld_wdt_stage { unsigned int id; u32 mask; }; struct kempld_wdt_data { struct kempld_device_data *pld; struct watchdog_device wdd; unsigned int pretimeout; struct kempld_wdt_stage stage[KEMPLD_WDT_MAX_STAGES]; #ifdef CONFIG_PM u8 pm_status_store; #endif }; #define DEFAULT_TIMEOUT 30 /* seconds */ #define DEFAULT_PRETIMEOUT 0 static unsigned int timeout = DEFAULT_TIMEOUT; module_param(timeout, uint, 0); MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. (>=0, default=" __MODULE_STRING(DEFAULT_TIMEOUT) ")"); static unsigned int pretimeout = DEFAULT_PRETIMEOUT; module_param(pretimeout, uint, 0); MODULE_PARM_DESC(pretimeout, "Watchdog pretimeout in seconds. (>=0, default=" __MODULE_STRING(DEFAULT_PRETIMEOUT) ")"); static bool nowayout = WATCHDOG_NOWAYOUT; module_param(nowayout, bool, 0); MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); static int kempld_wdt_set_stage_action(struct kempld_wdt_data *wdt_data, struct kempld_wdt_stage *stage, u8 action) { struct kempld_device_data *pld = wdt_data->pld; u8 stage_cfg; if (!stage || !stage->mask) return -EINVAL; kempld_get_mutex(pld); stage_cfg = kempld_read8(pld, KEMPLD_WDT_STAGE_CFG(stage->id)); stage_cfg &= ~STAGE_CFG_ACTION_MASK; stage_cfg |= (action & STAGE_CFG_ACTION_MASK); if (action == ACTION_RESET) stage_cfg |= STAGE_CFG_ASSERT; else stage_cfg &= ~STAGE_CFG_ASSERT; kempld_write8(pld, KEMPLD_WDT_STAGE_CFG(stage->id), stage_cfg); kempld_release_mutex(pld); return 0; } static int kempld_wdt_set_stage_timeout(struct kempld_wdt_data *wdt_data, struct kempld_wdt_stage *stage, unsigned int timeout) { struct kempld_device_data *pld = wdt_data->pld; u32 prescaler; u64 stage_timeout64; u32 stage_timeout; u32 remainder; u8 stage_cfg; prescaler = kempld_prescaler[PRESCALER_21]; if (!stage) return -EINVAL; stage_timeout64 = (u64)timeout * pld->pld_clock; remainder = do_div(stage_timeout64, prescaler); if (remainder) stage_timeout64++; if (stage_timeout64 > stage->mask) return -EINVAL; stage_timeout = stage_timeout64 & stage->mask; kempld_get_mutex(pld); stage_cfg = kempld_read8(pld, KEMPLD_WDT_STAGE_CFG(stage->id)); stage_cfg &= ~STAGE_CFG_PRESCALER_MASK; stage_cfg |= STAGE_CFG_SET_PRESCALER(PRESCALER_21); kempld_write8(pld, KEMPLD_WDT_STAGE_CFG(stage->id), stage_cfg); kempld_write32(pld, KEMPLD_WDT_STAGE_TIMEOUT(stage->id), stage_timeout); kempld_release_mutex(pld); return 0; } /* * kempld_get_mutex must be called prior to calling this function. */ static unsigned int kempld_wdt_get_timeout(struct kempld_wdt_data *wdt_data, struct kempld_wdt_stage *stage) { struct kempld_device_data *pld = wdt_data->pld; unsigned int timeout; u64 stage_timeout; u32 prescaler; u32 remainder; u8 stage_cfg; if (!stage->mask) return 0; stage_cfg = kempld_read8(pld, KEMPLD_WDT_STAGE_CFG(stage->id)); stage_timeout = kempld_read32(pld, KEMPLD_WDT_STAGE_TIMEOUT(stage->id)); prescaler = kempld_prescaler[STAGE_CFG_GET_PRESCALER(stage_cfg)]; stage_timeout = (stage_timeout & stage->mask) * prescaler; remainder = do_div(stage_timeout, pld->pld_clock); if (remainder) stage_timeout++; timeout = stage_timeout; WARN_ON_ONCE(timeout != stage_timeout); return timeout; } static int kempld_wdt_set_timeout(struct watchdog_device *wdd, unsigned int timeout) { struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); struct kempld_wdt_stage *pretimeout_stage; struct kempld_wdt_stage *timeout_stage; int ret; timeout_stage = &wdt_data->stage[STAGE_TIMEOUT]; pretimeout_stage = &wdt_data->stage[STAGE_PRETIMEOUT]; if (pretimeout_stage->mask && wdt_data->pretimeout > 0) timeout = wdt_data->pretimeout; ret = kempld_wdt_set_stage_action(wdt_data, timeout_stage, ACTION_RESET); if (ret) return ret; ret = kempld_wdt_set_stage_timeout(wdt_data, timeout_stage, timeout); if (ret) return ret; wdd->timeout = timeout; return 0; } static int kempld_wdt_set_pretimeout(struct watchdog_device *wdd, unsigned int pretimeout) { struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); struct kempld_wdt_stage *pretimeout_stage; u8 action = ACTION_NONE; int ret; pretimeout_stage = &wdt_data->stage[STAGE_PRETIMEOUT]; if (!pretimeout_stage->mask) return -ENXIO; if (pretimeout > wdd->timeout) return -EINVAL; if (pretimeout > 0) action = ACTION_NMI; ret = kempld_wdt_set_stage_action(wdt_data, pretimeout_stage, action); if (ret) return ret; ret = kempld_wdt_set_stage_timeout(wdt_data, pretimeout_stage, wdd->timeout - pretimeout); if (ret) return ret; wdt_data->pretimeout = pretimeout; return 0; } static void kempld_wdt_update_timeouts(struct kempld_wdt_data *wdt_data) { struct kempld_device_data *pld = wdt_data->pld; struct kempld_wdt_stage *pretimeout_stage; struct kempld_wdt_stage *timeout_stage; unsigned int pretimeout, timeout; pretimeout_stage = &wdt_data->stage[STAGE_PRETIMEOUT]; timeout_stage = &wdt_data->stage[STAGE_TIMEOUT]; kempld_get_mutex(pld); pretimeout = kempld_wdt_get_timeout(wdt_data, pretimeout_stage); timeout = kempld_wdt_get_timeout(wdt_data, timeout_stage); kempld_release_mutex(pld); if (pretimeout) wdt_data->pretimeout = timeout; else wdt_data->pretimeout = 0; wdt_data->wdd.timeout = pretimeout + timeout; } static int kempld_wdt_start(struct watchdog_device *wdd) { struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); struct kempld_device_data *pld = wdt_data->pld; u8 status; int ret; ret = kempld_wdt_set_timeout(wdd, wdd->timeout); if (ret) return ret; kempld_get_mutex(pld); status = kempld_read8(pld, KEMPLD_WDT_CFG); status |= KEMPLD_WDT_CFG_ENABLE; kempld_write8(pld, KEMPLD_WDT_CFG, status); status = kempld_read8(pld, KEMPLD_WDT_CFG); kempld_release_mutex(pld); /* Check if the watchdog was enabled */ if (!(status & KEMPLD_WDT_CFG_ENABLE)) return -EACCES; return 0; } static int kempld_wdt_stop(struct watchdog_device *wdd) { struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); struct kempld_device_data *pld = wdt_data->pld; u8 status; kempld_get_mutex(pld); status = kempld_read8(pld, KEMPLD_WDT_CFG); status &= ~KEMPLD_WDT_CFG_ENABLE; kempld_write8(pld, KEMPLD_WDT_CFG, status); status = kempld_read8(pld, KEMPLD_WDT_CFG); kempld_release_mutex(pld); /* Check if the watchdog was disabled */ if (status & KEMPLD_WDT_CFG_ENABLE) return -EACCES; return 0; } static int kempld_wdt_keepalive(struct watchdog_device *wdd) { struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); struct kempld_device_data *pld = wdt_data->pld; kempld_get_mutex(pld); kempld_write8(pld, KEMPLD_WDT_KICK, 'K'); kempld_release_mutex(pld); return 0; } static long kempld_wdt_ioctl(struct watchdog_device *wdd, unsigned int cmd, unsigned long arg) { struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); void __user *argp = (void __user *)arg; int ret = -ENOIOCTLCMD; int __user *p = argp; int new_value; switch (cmd) { case WDIOC_SETPRETIMEOUT: if (get_user(new_value, p)) return -EFAULT; ret = kempld_wdt_set_pretimeout(wdd, new_value); if (ret) return ret; ret = kempld_wdt_keepalive(wdd); break; case WDIOC_GETPRETIMEOUT: ret = put_user(wdt_data->pretimeout, (int __user *)arg); break; } return ret; } static int kempld_wdt_probe_stages(struct watchdog_device *wdd) { struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); struct kempld_device_data *pld = wdt_data->pld; struct kempld_wdt_stage *pretimeout_stage; struct kempld_wdt_stage *timeout_stage; u8 index, data, data_orig; u32 mask; int i, j; pretimeout_stage = &wdt_data->stage[STAGE_PRETIMEOUT]; timeout_stage = &wdt_data->stage[STAGE_TIMEOUT]; pretimeout_stage->mask = 0; timeout_stage->mask = 0; for (i = 0; i < 3; i++) { index = KEMPLD_WDT_STAGE_TIMEOUT(i); mask = 0; kempld_get_mutex(pld); /* Probe each byte individually. */ for (j = 0; j < 4; j++) { data_orig = kempld_read8(pld, index + j); kempld_write8(pld, index + j, 0x00); data = kempld_read8(pld, index + j); /* A failed write means this byte is reserved */ if (data != 0x00) break; kempld_write8(pld, index + j, data_orig); mask |= 0xff << (j * 8); } kempld_release_mutex(pld); /* Assign available stages to timeout and pretimeout */ if (!timeout_stage->mask) { timeout_stage->mask = mask; timeout_stage->id = i; } else { if (pld->feature_mask & KEMPLD_FEATURE_BIT_NMI) { pretimeout_stage->mask = timeout_stage->mask; timeout_stage->mask = mask; pretimeout_stage->id = timeout_stage->id; timeout_stage->id = i; } break; } } if (!timeout_stage->mask) return -ENODEV; return 0; } static const struct watchdog_info kempld_wdt_info = { .identity = "KEMPLD Watchdog", .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE | WDIOF_PRETIMEOUT }; static const struct watchdog_ops kempld_wdt_ops = { .owner = THIS_MODULE, .start = kempld_wdt_start, .stop = kempld_wdt_stop, .ping = kempld_wdt_keepalive, .set_timeout = kempld_wdt_set_timeout, .ioctl = kempld_wdt_ioctl, }; static int kempld_wdt_probe(struct platform_device *pdev) { struct kempld_device_data *pld = dev_get_drvdata(pdev->dev.parent); struct kempld_wdt_data *wdt_data; struct device *dev = &pdev->dev; struct watchdog_device *wdd; u8 status; int ret = 0; wdt_data = devm_kzalloc(dev, sizeof(*wdt_data), GFP_KERNEL); if (!wdt_data) return -ENOMEM; wdt_data->pld = pld; wdd = &wdt_data->wdd; wdd->parent = dev; kempld_get_mutex(pld); status = kempld_read8(pld, KEMPLD_WDT_CFG); kempld_release_mutex(pld); /* Enable nowayout if watchdog is already locked */ if (status & (KEMPLD_WDT_CFG_ENABLE_LOCK | KEMPLD_WDT_CFG_GLOBAL_LOCK)) { if (!nowayout) dev_warn(dev, "Forcing nowayout - watchdog lock enabled!\n"); nowayout = true; } wdd->info = &kempld_wdt_info; wdd->ops = &kempld_wdt_ops; watchdog_set_drvdata(wdd, wdt_data); watchdog_set_nowayout(wdd, nowayout); ret = kempld_wdt_probe_stages(wdd); if (ret) return ret; kempld_wdt_set_timeout(wdd, timeout); kempld_wdt_set_pretimeout(wdd, pretimeout); /* Check if watchdog is already enabled */ if (status & KEMPLD_WDT_CFG_ENABLE) { /* Get current watchdog settings */ kempld_wdt_update_timeouts(wdt_data); dev_info(dev, "Watchdog was already enabled\n"); } platform_set_drvdata(pdev, wdt_data); watchdog_stop_on_reboot(wdd); watchdog_stop_on_unregister(wdd); ret = devm_watchdog_register_device(dev, wdd); if (ret) return ret; dev_info(dev, "Watchdog registered with %ds timeout\n", wdd->timeout); return 0; } #ifdef CONFIG_PM /* Disable watchdog if it is active during suspend */ static int kempld_wdt_suspend(struct platform_device *pdev, pm_message_t message) { struct kempld_wdt_data *wdt_data = platform_get_drvdata(pdev); struct kempld_device_data *pld = wdt_data->pld; struct watchdog_device *wdd = &wdt_data->wdd; kempld_get_mutex(pld); wdt_data->pm_status_store = kempld_read8(pld, KEMPLD_WDT_CFG); kempld_release_mutex(pld); kempld_wdt_update_timeouts(wdt_data); if (wdt_data->pm_status_store & KEMPLD_WDT_CFG_ENABLE) return kempld_wdt_stop(wdd); return 0; } /* Enable watchdog and configure it if necessary */ static int kempld_wdt_resume(struct platform_device *pdev) { struct kempld_wdt_data *wdt_data = platform_get_drvdata(pdev); struct watchdog_device *wdd = &wdt_data->wdd; /* * If watchdog was stopped before suspend be sure it gets disabled * again, for the case BIOS has enabled it during resume */ if (wdt_data->pm_status_store & KEMPLD_WDT_CFG_ENABLE) return kempld_wdt_start(wdd); else return kempld_wdt_stop(wdd); } #else #define kempld_wdt_suspend NULL #define kempld_wdt_resume NULL #endif static struct platform_driver kempld_wdt_driver = { .driver = { .name = "kempld-wdt", }, .probe = kempld_wdt_probe, .suspend = kempld_wdt_suspend, .resume = kempld_wdt_resume, }; module_platform_driver(kempld_wdt_driver); MODULE_DESCRIPTION("KEM PLD Watchdog Driver"); MODULE_AUTHOR("Michael Brunner <michael.brunner@kontron.com>"); MODULE_LICENSE("GPL");
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1