Merge git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6 into next

[cascardo/linux.git] / drivers / watchdog / xen_wdt.c

diff --git a/drivers/watchdog/xen_wdt.c b/drivers/watchdog/xen_wdt.c
index 49bd9d3..e4a25b5 100644 (file)
--- a/drivers/watchdog/xen_wdt.c
+++ b/drivers/watchdog/xen_wdt.c
@@ -9,9 +9,10 @@
  *     2 of the License, or (at your option) any later version.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #define DRV_NAME       "wdt"
 #define DRV_VERSION    "0.01"
-#define PFX            DRV_NAME ": "
 
 #include <linux/bug.h>
 #include <linux/errno.h>
@@ -131,16 +132,17 @@ static int xen_wdt_open(struct inode *inode, struct file *file)
 
 static int xen_wdt_release(struct inode *inode, struct file *file)
 {
+       int err = 0;
+
        if (expect_release)
-               xen_wdt_stop();
+               err = xen_wdt_stop();
        else {
-               printk(KERN_CRIT PFX
-                      "unexpected close, not stopping watchdog!\n");
+               pr_crit("unexpected close, not stopping watchdog!\n");
                xen_wdt_kick();
        }
-       is_active = false;
+       is_active = err;
        expect_release = false;
-       return 0;
+       return err;
 }
 
 static ssize_t xen_wdt_write(struct file *file, const char __user *data,
@@ -251,30 +253,27 @@ static int __devinit xen_wdt_probe(struct platform_device *dev)
        case -EINVAL:
                if (!timeout) {
                        timeout = WATCHDOG_TIMEOUT;
-                       printk(KERN_INFO PFX
-                              "timeout value invalid, using %d\n", timeout);
+                       pr_info("timeout value invalid, using %d\n", timeout);
                }
 
                ret = misc_register(&xen_wdt_miscdev);
                if (ret) {
-                       printk(KERN_ERR PFX
-                              "cannot register miscdev on minor=%d (%d)\n",
+                       pr_err("cannot register miscdev on minor=%d (%d)\n",
                               WATCHDOG_MINOR, ret);
                        break;
                }
 
-               printk(KERN_INFO PFX
-                      "initialized (timeout=%ds, nowayout=%d)\n",
-                      timeout, nowayout);
+               pr_info("initialized (timeout=%ds, nowayout=%d)\n",
+                       timeout, nowayout);
                break;
 
        case -ENOSYS:
-               printk(KERN_INFO PFX "not supported\n");
+               pr_info("not supported\n");
                ret = -ENODEV;
                break;
 
        default:
-               printk(KERN_INFO PFX "bogus return value %d\n", ret);
+               pr_info("bogus return value %d\n", ret);
                break;
        }
 
@@ -299,11 +298,18 @@ static void xen_wdt_shutdown(struct platform_device *dev)
 
 static int xen_wdt_suspend(struct platform_device *dev, pm_message_t state)
 {
-       return xen_wdt_stop();
+       typeof(wdt.id) id = wdt.id;
+       int rc = xen_wdt_stop();
+
+       wdt.id = id;
+       return rc;
 }
 
 static int xen_wdt_resume(struct platform_device *dev)
 {
+       if (!wdt.id)
+               return 0;
+       wdt.id = 0;
        return xen_wdt_start();
 }
 
@@ -326,7 +332,7 @@ static int __init xen_wdt_init_module(void)
        if (!xen_domain())
                return -ENODEV;
 
-       printk(KERN_INFO PFX "Xen WatchDog Timer Driver v%s\n", DRV_VERSION);
+       pr_info("Xen WatchDog Timer Driver v%s\n", DRV_VERSION);
 
        err = platform_driver_register(&xen_wdt_driver);
        if (err)
@@ -346,7 +352,7 @@ static void __exit xen_wdt_cleanup_module(void)
 {
        platform_device_unregister(platform_device);
        platform_driver_unregister(&xen_wdt_driver);
-       printk(KERN_INFO PFX "module unloaded\n");
+       pr_info("module unloaded\n");
 }
 
 module_init(xen_wdt_init_module);