Version:  2.0.40 2.2.26 2.4.37 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7

Linux/drivers/watchdog/stmp3xxx_rtc_wdt.c

  1 /*
  2  * Watchdog driver for the RTC based watchdog in STMP3xxx and i.MX23/28
  3  *
  4  * Author: Wolfram Sang <kernel@pengutronix.de>
  5  *
  6  * Copyright (C) 2011-12 Wolfram Sang, Pengutronix
  7  *
  8  * This program is free software; you can redistribute it and/or modify it
  9  * under the terms of the GNU General Public License version 2 as published by
 10  * the Free Software Foundation.
 11  */
 12 #include <linux/kernel.h>
 13 #include <linux/module.h>
 14 #include <linux/watchdog.h>
 15 #include <linux/platform_device.h>
 16 #include <linux/stmp3xxx_rtc_wdt.h>
 17 #include <linux/notifier.h>
 18 #include <linux/reboot.h>
 19 
 20 #define WDOG_TICK_RATE 1000 /* 1 kHz clock */
 21 #define STMP3XXX_DEFAULT_TIMEOUT 19
 22 #define STMP3XXX_MAX_TIMEOUT (UINT_MAX / WDOG_TICK_RATE)
 23 
 24 static int heartbeat = STMP3XXX_DEFAULT_TIMEOUT;
 25 module_param(heartbeat, uint, 0);
 26 MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat period in seconds from 1 to "
 27                  __MODULE_STRING(STMP3XXX_MAX_TIMEOUT) ", default "
 28                  __MODULE_STRING(STMP3XXX_DEFAULT_TIMEOUT));
 29 
 30 static int wdt_start(struct watchdog_device *wdd)
 31 {
 32         struct device *dev = watchdog_get_drvdata(wdd);
 33         struct stmp3xxx_wdt_pdata *pdata = dev_get_platdata(dev);
 34 
 35         pdata->wdt_set_timeout(dev->parent, wdd->timeout * WDOG_TICK_RATE);
 36         return 0;
 37 }
 38 
 39 static int wdt_stop(struct watchdog_device *wdd)
 40 {
 41         struct device *dev = watchdog_get_drvdata(wdd);
 42         struct stmp3xxx_wdt_pdata *pdata = dev_get_platdata(dev);
 43 
 44         pdata->wdt_set_timeout(dev->parent, 0);
 45         return 0;
 46 }
 47 
 48 static int wdt_set_timeout(struct watchdog_device *wdd, unsigned new_timeout)
 49 {
 50         wdd->timeout = new_timeout;
 51         return wdt_start(wdd);
 52 }
 53 
 54 static const struct watchdog_info stmp3xxx_wdt_ident = {
 55         .options = WDIOF_MAGICCLOSE | WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
 56         .identity = "STMP3XXX RTC Watchdog",
 57 };
 58 
 59 static const struct watchdog_ops stmp3xxx_wdt_ops = {
 60         .owner = THIS_MODULE,
 61         .start = wdt_start,
 62         .stop = wdt_stop,
 63         .set_timeout = wdt_set_timeout,
 64 };
 65 
 66 static struct watchdog_device stmp3xxx_wdd = {
 67         .info = &stmp3xxx_wdt_ident,
 68         .ops = &stmp3xxx_wdt_ops,
 69         .min_timeout = 1,
 70         .max_timeout = STMP3XXX_MAX_TIMEOUT,
 71         .status = WATCHDOG_NOWAYOUT_INIT_STATUS,
 72 };
 73 
 74 static int wdt_notify_sys(struct notifier_block *nb, unsigned long code,
 75                           void *unused)
 76 {
 77         switch (code) {
 78         case SYS_DOWN:  /* keep enabled, system might crash while going down */
 79                 break;
 80         case SYS_HALT:  /* allow the system to actually halt */
 81         case SYS_POWER_OFF:
 82                 wdt_stop(&stmp3xxx_wdd);
 83                 break;
 84         }
 85 
 86         return NOTIFY_DONE;
 87 }
 88 
 89 static struct notifier_block wdt_notifier = {
 90         .notifier_call = wdt_notify_sys,
 91 };
 92 
 93 static int stmp3xxx_wdt_probe(struct platform_device *pdev)
 94 {
 95         int ret;
 96 
 97         watchdog_set_drvdata(&stmp3xxx_wdd, &pdev->dev);
 98 
 99         stmp3xxx_wdd.timeout = clamp_t(unsigned, heartbeat, 1, STMP3XXX_MAX_TIMEOUT);
100         stmp3xxx_wdd.parent = &pdev->dev;
101 
102         ret = watchdog_register_device(&stmp3xxx_wdd);
103         if (ret < 0) {
104                 dev_err(&pdev->dev, "cannot register watchdog device\n");
105                 return ret;
106         }
107 
108         if (register_reboot_notifier(&wdt_notifier))
109                 dev_warn(&pdev->dev, "cannot register reboot notifier\n");
110 
111         dev_info(&pdev->dev, "initialized watchdog with heartbeat %ds\n",
112                         stmp3xxx_wdd.timeout);
113         return 0;
114 }
115 
116 static int stmp3xxx_wdt_remove(struct platform_device *pdev)
117 {
118         unregister_reboot_notifier(&wdt_notifier);
119         watchdog_unregister_device(&stmp3xxx_wdd);
120         return 0;
121 }
122 
123 static int __maybe_unused stmp3xxx_wdt_suspend(struct device *dev)
124 {
125         struct watchdog_device *wdd = &stmp3xxx_wdd;
126 
127         if (watchdog_active(wdd))
128                 return wdt_stop(wdd);
129 
130         return 0;
131 }
132 
133 static int __maybe_unused stmp3xxx_wdt_resume(struct device *dev)
134 {
135         struct watchdog_device *wdd = &stmp3xxx_wdd;
136 
137         if (watchdog_active(wdd))
138                 return wdt_start(wdd);
139 
140         return 0;
141 }
142 
143 static SIMPLE_DEV_PM_OPS(stmp3xxx_wdt_pm_ops,
144                          stmp3xxx_wdt_suspend, stmp3xxx_wdt_resume);
145 
146 static struct platform_driver stmp3xxx_wdt_driver = {
147         .driver = {
148                 .name = "stmp3xxx_rtc_wdt",
149                 .pm = &stmp3xxx_wdt_pm_ops,
150         },
151         .probe = stmp3xxx_wdt_probe,
152         .remove = stmp3xxx_wdt_remove,
153 };
154 module_platform_driver(stmp3xxx_wdt_driver);
155 
156 MODULE_DESCRIPTION("STMP3XXX RTC Watchdog Driver");
157 MODULE_LICENSE("GPL v2");
158 MODULE_AUTHOR("Wolfram Sang <kernel@pengutronix.de>");
159 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us