watchdog: Use pr_<fmt> and pr_<level>

[sfrench/cifs-2.6.git] / drivers / watchdog / pnx4008_wdt.c

diff --git a/drivers/watchdog/pnx4008_wdt.c b/drivers/watchdog/pnx4008_wdt.c
index dfae030a7ef2553ee6e2d44b59834bc4e3e57003..ae927093cb6df28e0dcba1cf1238f3154e25f2a5 100644 (file)
--- a/drivers/watchdog/pnx4008_wdt.c
+++ b/drivers/watchdog/pnx4008_wdt.c
@@ -14,6 +14,8 @@
  * or implied.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/types.h>
@@ -84,12 +86,9 @@ static DEFINE_SPINLOCK(io_lock);
 static unsigned long wdt_status;
 #define WDT_IN_USE        0
 #define WDT_OK_TO_CLOSE   1
-#define WDT_REGION_INITED 2
-#define WDT_DEVICE_INITED 3
 
 static unsigned long boot_status;
 
-static struct resource *wdt_mem;
 static void __iomem    *wdt_base;
 struct clk             *wdt_clk;
 
@@ -98,22 +97,21 @@ static void wdt_enable(void)
        spin_lock(&io_lock);
 
        /* stop counter, initiate counter reset */
-       __raw_writel(RESET_COUNT, WDTIM_CTRL(wdt_base));
+       writel(RESET_COUNT, WDTIM_CTRL(wdt_base));
        /*wait for reset to complete. 100% guarantee event */
-       while (__raw_readl(WDTIM_COUNTER(wdt_base)))
+       while (readl(WDTIM_COUNTER(wdt_base)))
                cpu_relax();
        /* internal and external reset, stop after that */
-       __raw_writel(M_RES2 | STOP_COUNT0 | RESET_COUNT0,
-               WDTIM_MCTRL(wdt_base));
+       writel(M_RES2 | STOP_COUNT0 | RESET_COUNT0, WDTIM_MCTRL(wdt_base));
        /* configure match output */
-       __raw_writel(MATCH_OUTPUT_HIGH, WDTIM_EMR(wdt_base));
+       writel(MATCH_OUTPUT_HIGH, WDTIM_EMR(wdt_base));
        /* clear interrupt, just in case */
-       __raw_writel(MATCH_INT, WDTIM_INT(wdt_base));
+       writel(MATCH_INT, WDTIM_INT(wdt_base));
        /* the longest pulse period 65541/(13*10^6) seconds ~ 5 ms. */
-       __raw_writel(0xFFFF, WDTIM_PULSE(wdt_base));
-       __raw_writel(heartbeat * WDOG_COUNTER_RATE, WDTIM_MATCH0(wdt_base));
+       writel(0xFFFF, WDTIM_PULSE(wdt_base));
+       writel(heartbeat * WDOG_COUNTER_RATE, WDTIM_MATCH0(wdt_base));
        /*enable counter, stop when debugger active */
-       __raw_writel(COUNT_ENAB | DEBUG_EN, WDTIM_CTRL(wdt_base));
+       writel(COUNT_ENAB | DEBUG_EN, WDTIM_CTRL(wdt_base));
 
        spin_unlock(&io_lock);
 }
@@ -122,7 +120,7 @@ static void wdt_disable(void)
 {
        spin_lock(&io_lock);
 
-       __raw_writel(0, WDTIM_CTRL(wdt_base));  /*stop counter */
+       writel(0, WDTIM_CTRL(wdt_base));        /*stop counter */
 
        spin_unlock(&io_lock);
 }
@@ -226,7 +224,7 @@ static long pnx4008_wdt_ioctl(struct file *file, unsigned int cmd,
 static int pnx4008_wdt_release(struct inode *inode, struct file *file)
 {
        if (!test_bit(WDT_OK_TO_CLOSE, &wdt_status))
-               printk(KERN_WARNING "WATCHDOG: Device closed unexpectedly\n");
+               pr_warn("Device closed unexpectedly\n");
 
        wdt_disable();
        clk_disable(wdt_clk);
@@ -253,61 +251,43 @@ static struct miscdevice pnx4008_wdt_miscdev = {
 
 static int __devinit pnx4008_wdt_probe(struct platform_device *pdev)
 {
-       int ret = 0, size;
+       struct resource *r;
+       int ret = 0;
 
        if (heartbeat < 1 || heartbeat > MAX_HEARTBEAT)
                heartbeat = DEFAULT_HEARTBEAT;
 
-       printk(KERN_INFO MODULE_NAME
-               "PNX4008 Watchdog Timer: heartbeat %d sec\n", heartbeat);
-
-       wdt_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       if (wdt_mem == NULL) {
-               printk(KERN_INFO MODULE_NAME
-                       "failed to get memory region resource\n");
-               return -ENOENT;
-       }
-
-       size = resource_size(wdt_mem);
-
-       if (!request_mem_region(wdt_mem->start, size, pdev->name)) {
-               printk(KERN_INFO MODULE_NAME "failed to get memory region\n");
-               return -ENOENT;
-       }
-       wdt_base = (void __iomem *)IO_ADDRESS(wdt_mem->start);
+       r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+       wdt_base = devm_request_and_ioremap(&pdev->dev, r);
+       if (!wdt_base)
+               return -EADDRINUSE;
 
        wdt_clk = clk_get(&pdev->dev, NULL);
-       if (IS_ERR(wdt_clk)) {
-               ret = PTR_ERR(wdt_clk);
-               release_mem_region(wdt_mem->start, size);
-               wdt_mem = NULL;
-               goto out;
-       }
+       if (IS_ERR(wdt_clk))
+               return PTR_ERR(wdt_clk);
 
        ret = clk_enable(wdt_clk);
-       if (ret) {
-               release_mem_region(wdt_mem->start, size);
-               wdt_mem = NULL;
-               clk_put(wdt_clk);
+       if (ret)
                goto out;
-       }
+
+       boot_status = (readl(WDTIM_RES(wdt_base)) & WDOG_RESET) ?
+                       WDIOF_CARDRESET : 0;
+       wdt_disable();          /*disable for now */
+       clk_disable(wdt_clk);
 
        ret = misc_register(&pnx4008_wdt_miscdev);
        if (ret < 0) {
-               printk(KERN_ERR MODULE_NAME "cannot register misc device\n");
-               release_mem_region(wdt_mem->start, size);
-               wdt_mem = NULL;
-               clk_disable(wdt_clk);
-               clk_put(wdt_clk);
-       } else {
-               boot_status = (__raw_readl(WDTIM_RES(wdt_base)) & WDOG_RESET) ?
-                   WDIOF_CARDRESET : 0;
-               wdt_disable();          /*disable for now */
-               clk_disable(wdt_clk);
-               set_bit(WDT_DEVICE_INITED, &wdt_status);
+               dev_err(&pdev->dev, "cannot register misc device\n");
+               goto out;
        }
 
+       dev_info(&pdev->dev, "PNX4008 Watchdog Timer: heartbeat %d sec\n",
+                       heartbeat);
+
+       return 0;
+
 out:
+       clk_put(wdt_clk);
        return ret;
 }
 
@@ -318,10 +298,6 @@ static int __devexit pnx4008_wdt_remove(struct platform_device *pdev)
        clk_disable(wdt_clk);
        clk_put(wdt_clk);
 
-       if (wdt_mem) {
-               release_mem_region(wdt_mem->start, resource_size(wdt_mem));
-               wdt_mem = NULL;
-       }
        return 0;
 }