/* * Driver for watchdog device controlled through GPIO-line * * Author: 2013, Alexander Shiyan * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. */ #include #include #include #include #include #include #define SOFT_TIMEOUT_MIN 1 #define SOFT_TIMEOUT_DEF 60 #define SOFT_TIMEOUT_MAX 0xffff enum { HW_ALGO_TOGGLE, HW_ALGO_LEVEL, }; struct gpio_wdt_priv { int gpio; bool active_low; bool state; bool always_running; bool armed; unsigned int hw_algo; unsigned int hw_margin; unsigned long last_jiffies; struct timer_list timer; struct watchdog_device wdd; }; static void gpio_wdt_disable(struct gpio_wdt_priv *priv) { gpio_set_value_cansleep(priv->gpio, !priv->active_low); /* Put GPIO back to tristate */ if (priv->hw_algo == HW_ALGO_TOGGLE) gpio_direction_input(priv->gpio); } static void gpio_wdt_hwping(unsigned long data) { struct watchdog_device *wdd = (struct watchdog_device *)data; struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd); if (priv->armed && time_after(jiffies, priv->last_jiffies + msecs_to_jiffies(wdd->timeout * 1000))) { dev_crit(wdd->parent, "Timer expired. System will reboot soon!\n"); return; } /* Restart timer */ mod_timer(&priv->timer, jiffies + priv->hw_margin); switch (priv->hw_algo) { case HW_ALGO_TOGGLE: /* Toggle output pin */ priv->state = !priv->state; gpio_set_value_cansleep(priv->gpio, priv->state); break; case HW_ALGO_LEVEL: /* Pulse */ gpio_set_value_cansleep(priv->gpio, !priv->active_low); udelay(1); gpio_set_value_cansleep(priv->gpio, priv->active_low); break; } } static void gpio_wdt_start_impl(struct gpio_wdt_priv *priv) { priv->state = priv->active_low; gpio_direction_output(priv->gpio, priv->state); priv->last_jiffies = jiffies; gpio_wdt_hwping((unsigned long)&priv->wdd); } static int gpio_wdt_start(struct watchdog_device *wdd) { struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd); gpio_wdt_start_impl(priv); priv->armed = true; return 0; } static int gpio_wdt_stop(struct watchdog_device *wdd) { struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd); priv->armed = false; if (!priv->always_running) { mod_timer(&priv->timer, 0); gpio_wdt_disable(priv); } return 0; } static int gpio_wdt_ping(struct watchdog_device *wdd) { struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd); priv->last_jiffies = jiffies; return 0; } static int gpio_wdt_set_timeout(struct watchdog_device *wdd, unsigned int t) { wdd->timeout = t; return gpio_wdt_ping(wdd); } static const struct watchdog_info gpio_wdt_ident = { .options = WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT, .identity = "GPIO Watchdog", }; static const struct watchdog_ops gpio_wdt_ops = { .owner = THIS_MODULE, .start = gpio_wdt_start, .stop = gpio_wdt_stop, .ping = gpio_wdt_ping, .set_timeout = gpio_wdt_set_timeout, }; static int gpio_wdt_probe(struct platform_device *pdev) { struct gpio_wdt_priv *priv; enum of_gpio_flags flags; unsigned int hw_margin; unsigned long f = 0; const char *algo; int ret; priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; platform_set_drvdata(pdev, priv); priv->gpio = of_get_gpio_flags(pdev->dev.of_node, 0, &flags); if (!gpio_is_valid(priv->gpio)) return priv->gpio; priv->active_low = flags & OF_GPIO_ACTIVE_LOW; ret = of_property_read_string(pdev->dev.of_node, "hw_algo", &algo); if (ret) return ret; if (!strcmp(algo, "toggle")) { priv->hw_algo = HW_ALGO_TOGGLE; f = GPIOF_IN; } else if (!strcmp(algo, "level")) { priv->hw_algo = HW_ALGO_LEVEL; f = priv->active_low ? GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW; } else { return -EINVAL; } ret = devm_gpio_request_one(&pdev->dev, priv->gpio, f, dev_name(&pdev->dev)); if (ret) return ret; ret = of_property_read_u32(pdev->dev.of_node, "hw_margin_ms", &hw_margin); if (ret) return ret; /* Disallow values lower than 2 and higher than 65535 ms */ if (hw_margin < 2 || hw_margin > 65535) return -EINVAL; /* Use safe value (1/2 of real timeout) */ priv->hw_margin = msecs_to_jiffies(hw_margin / 2); priv->always_running = of_property_read_bool(pdev->dev.of_node, "always-running"); watchdog_set_drvdata(&priv->wdd, priv); priv->wdd.info = &gpio_wdt_ident; priv->wdd.ops = &gpio_wdt_ops; priv->wdd.min_timeout = SOFT_TIMEOUT_MIN; priv->wdd.max_timeout = SOFT_TIMEOUT_MAX; priv->wdd.parent = &pdev->dev; if (watchdog_init_timeout(&priv->wdd, 0, &pdev->dev) < 0) priv->wdd.timeout = SOFT_TIMEOUT_DEF; setup_timer(&priv->timer, gpio_wdt_hwping, (unsigned long)&priv->wdd); watchdog_stop_on_reboot(&priv->wdd); ret = watchdog_register_device(&priv->wdd); if (ret) return ret; if (priv->always_running) gpio_wdt_start_impl(priv); return 0; } static int gpio_wdt_remove(struct platform_device *pdev) { struct gpio_wdt_priv *priv = platform_get_drvdata(pdev); del_timer_sync(&priv->timer); watchdog_unregister_device(&priv->wdd); return 0; } static const struct of_device_id gpio_wdt_dt_ids[] = { { .compatible = "linux,wdt-gpio", }, { } }; MODULE_DEVICE_TABLE(of, gpio_wdt_dt_ids); static struct platform_driver gpio_wdt_driver = { .driver = { .name = "gpio-wdt", .of_match_table = gpio_wdt_dt_ids, }, .probe = gpio_wdt_probe, .remove = gpio_wdt_remove, }; #ifdef CONFIG_GPIO_WATCHDOG_ARCH_INITCALL static int __init gpio_wdt_init(void) { return platform_driver_register(&gpio_wdt_driver); } arch_initcall(gpio_wdt_init); #else module_platform_driver(gpio_wdt_driver); #endif MODULE_AUTHOR("Alexander Shiyan "); MODULE_DESCRIPTION("GPIO Watchdog"); MODULE_LICENSE("GPL"); e field of a device structure. This field is of type const, so add const to declaration of device_type structure. File size before: text data bss dec hex filename 19278 3199 16 22493 57dd nvdimm/namespace_devs.o File size after: text data bss dec hex filename 19929 3160 16 23105 5a41 nvdimm/namespace_devs.o Signed-off-by: Bhumika Goyal <bhumirks@gmail.com> Signed-off-by: Dan Williams <dan.j.williams@intel.com>
Diffstat (limited to 'include/drm/drm_hashtab.h')