[ARM] Orion/Kirkwood: rename orion5x_wdt to orion_wdt

The Orion watchdog driver is also used on Kirkwood.

Convention is to use orion5x for stuff specific to 88F5xxx Orion chips
and simply "orion" for shared stuff across SoCs including Kirkwood.

Signed-off-by: Nicolas Pitre <nico@marvell.com>

3 files changed, 59 insertions, 59 deletions

diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index 1e983b1717d3..5744cac4864b 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -231,14 +231,14 @@ config DAVINCI_WATCHDOG
           NOTE: once enabled, this timer cannot be disabled.
           Say N if you are unsure.
 
-config ORION5X_WATCHDOG
-        tristate "Orion5x watchdog"
+config ORION_WATCHDOG
+        tristate "Orion watchdog"
         depends on ARCH_ORION5X || ARCH_KIRKWOOD
         help
           Say Y here if to include support for the watchdog timer
-          in the Orion5x and Kirkwood ARM SoCs.
+          in the Marvell Orion5x and Kirkwood ARM SoCs.
           To compile this driver as a module, choose M here: the
-          module will be called orion5x_wdt.
+          module will be called orion_wdt.
 
 # AVR32 Architecture
 
diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
index 7f8c56b14f58..c3afa14d5be1 100644
--- a/drivers/watchdog/Makefile
+++ b/drivers/watchdog/Makefile
@@ -40,7 +40,7 @@ obj-$(CONFIG_EP93XX_WATCHDOG) += ep93xx_wdt.o
 obj-$(CONFIG_PNX4008_WATCHDOG) += pnx4008_wdt.o
 obj-$(CONFIG_IOP_WATCHDOG) += iop_wdt.o
 obj-$(CONFIG_DAVINCI_WATCHDOG) += davinci_wdt.o
-obj-$(CONFIG_ORION5X_WATCHDOG) += orion5x_wdt.o
+obj-$(CONFIG_ORION_WATCHDOG) += orion_wdt.o
 
 # AVR32 Architecture
 obj-$(CONFIG_AT32AP700X_WDT) += at32ap700x_wdt.o
diff --git a/drivers/watchdog/orion5x_wdt.c b/drivers/watchdog/orion_wdt.c
index d2dc9762a8c9..2d9fb96a9ee9 100644
--- a/drivers/watchdog/orion5x_wdt.c
+++ b/drivers/watchdog/orion_wdt.c
@@ -1,7 +1,7 @@
 /*
- * drivers/watchdog/orion5x_wdt.c
+ * drivers/watchdog/orion_wdt.c
  *
- * Watchdog driver for Orion5x processors
+ * Watchdog driver for Orion/Kirkwood processors
  *
  * Author: Sylver Bruneau <sylver.bruneau@googlemail.com>
  *
@@ -23,7 +23,7 @@
 #include <linux/io.h>
 #include <linux/spinlock.h>
 #include <mach/bridge-regs.h>
-#include <plat/orion5x_wdt.h>
+#include <plat/orion_wdt.h>
 
 /*
  * Watchdog timer block registers.
@@ -43,7 +43,7 @@ static unsigned int wdt_tclk;
 static unsigned long wdt_status;
 static spinlock_t wdt_lock;
 
-static void orion5x_wdt_ping(void)
+static void orion_wdt_ping(void)
 {
         spin_lock(&wdt_lock);
 
@@ -53,7 +53,7 @@ static void orion5x_wdt_ping(void)
         spin_unlock(&wdt_lock);
 }
 
-static void orion5x_wdt_enable(void)
+static void orion_wdt_enable(void)
 {
         u32 reg;
 
@@ -80,7 +80,7 @@ static void orion5x_wdt_enable(void)
         spin_unlock(&wdt_lock);
 }
 
-static void orion5x_wdt_disable(void)
+static void orion_wdt_disable(void)
 {
         u32 reg;
 
@@ -99,7 +99,7 @@ static void orion5x_wdt_disable(void)
         spin_unlock(&wdt_lock);
 }
 
-static int orion5x_wdt_get_timeleft(int *time_left)
+static int orion_wdt_get_timeleft(int *time_left)
 {
         spin_lock(&wdt_lock);
         *time_left = readl(WDT_VAL) / wdt_tclk;
@@ -107,16 +107,16 @@ static int orion5x_wdt_get_timeleft(int *time_left)
         return 0;
 }
 
-static int orion5x_wdt_open(struct inode *inode, struct file *file)
+static int orion_wdt_open(struct inode *inode, struct file *file)
 {
         if (test_and_set_bit(WDT_IN_USE, &wdt_status))
                 return -EBUSY;
         clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
-        orion5x_wdt_enable();
+        orion_wdt_enable();
         return nonseekable_open(inode, file);
 }
 
-static ssize_t orion5x_wdt_write(struct file *file, const char *data,
+static ssize_t orion_wdt_write(struct file *file, const char *data,
                                         size_t len, loff_t *ppos)
 {
         if (len) {
@@ -133,18 +133,18 @@ static ssize_t orion5x_wdt_write(struct file *file, const char *data,
                                         set_bit(WDT_OK_TO_CLOSE, &wdt_status);
                         }
                 }
-                orion5x_wdt_ping();
+                orion_wdt_ping();
         }
         return len;
 }
 
-static int orion5x_wdt_settimeout(int new_time)
+static int orion_wdt_settimeout(int new_time)
 {
         if ((new_time <= 0) || (new_time > wdt_max_duration))
                 return -EINVAL;
 
         /* Set new watchdog time to be used when
-         * orion5x_wdt_enable() or orion5x_wdt_ping() is called. */
+         * orion_wdt_enable() or orion_wdt_ping() is called. */
         heartbeat = new_time;
         return 0;
 }
@@ -152,10 +152,10 @@ static int orion5x_wdt_settimeout(int new_time)
 static const struct watchdog_info ident = {
         .options        = WDIOF_MAGICCLOSE | WDIOF_SETTIMEOUT |
                           WDIOF_KEEPALIVEPING,
-        .identity       = "Orion5x Watchdog",
+        .identity       = "Orion Watchdog",
 };
 
-static long orion5x_wdt_ioctl(struct file *file, unsigned int cmd,
+static long orion_wdt_ioctl(struct file *file, unsigned int cmd,
                                 unsigned long arg)
 {
         int ret = -ENOTTY;
@@ -173,7 +173,7 @@ static long orion5x_wdt_ioctl(struct file *file, unsigned int cmd,
                 break;
 
         case WDIOC_KEEPALIVE:
-                orion5x_wdt_ping();
+                orion_wdt_ping();
                 ret = 0;
                 break;
 
@@ -182,11 +182,11 @@ static long orion5x_wdt_ioctl(struct file *file, unsigned int cmd,
                 if (ret)
                         break;
 
-                if (orion5x_wdt_settimeout(time)) {
+                if (orion_wdt_settimeout(time)) {
                         ret = -EINVAL;
                         break;
                 }
-                orion5x_wdt_ping();
+                orion_wdt_ping();
                 /* Fall through */
 
         case WDIOC_GETTIMEOUT:
@@ -194,7 +194,7 @@ static long orion5x_wdt_ioctl(struct file *file, unsigned int cmd,
                 break;
 
         case WDIOC_GETTIMELEFT:
-                if (orion5x_wdt_get_timeleft(&time)) {
+                if (orion_wdt_get_timeleft(&time)) {
                         ret = -EINVAL;
                         break;
                 }
@@ -204,10 +204,10 @@ static long orion5x_wdt_ioctl(struct file *file, unsigned int cmd,
         return ret;
 }
 
-static int orion5x_wdt_release(struct inode *inode, struct file *file)
+static int orion_wdt_release(struct inode *inode, struct file *file)
 {
         if (test_bit(WDT_OK_TO_CLOSE, &wdt_status))
-                orion5x_wdt_disable();
+                orion_wdt_disable();
         else
                 printk(KERN_CRIT "WATCHDOG: Device closed unexpectedly - "
                                         "timer will not stop\n");
@@ -218,98 +218,98 @@ static int orion5x_wdt_release(struct inode *inode, struct file *file)
 }
 
 
-static const struct file_operations orion5x_wdt_fops = {
+static const struct file_operations orion_wdt_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
-        .write          = orion5x_wdt_write,
-        .unlocked_ioctl = orion5x_wdt_ioctl,
-        .open           = orion5x_wdt_open,
-        .release        = orion5x_wdt_release,
+        .write          = orion_wdt_write,
+        .unlocked_ioctl = orion_wdt_ioctl,
+        .open           = orion_wdt_open,
+        .release        = orion_wdt_release,
 };
 
-static struct miscdevice orion5x_wdt_miscdev = {
+static struct miscdevice orion_wdt_miscdev = {
         .minor          = WATCHDOG_MINOR,
         .name           = "watchdog",
-        .fops           = &orion5x_wdt_fops,
+        .fops           = &orion_wdt_fops,
 };
 
-static int __devinit orion5x_wdt_probe(struct platform_device *pdev)
+static int __devinit orion_wdt_probe(struct platform_device *pdev)
 {
-        struct orion5x_wdt_platform_data *pdata = pdev->dev.platform_data;
+        struct orion_wdt_platform_data *pdata = pdev->dev.platform_data;
         int ret;
 
         if (pdata) {
                 wdt_tclk = pdata->tclk;
         } else {
-                printk(KERN_ERR "Orion5x Watchdog misses platform data\n");
+                printk(KERN_ERR "Orion Watchdog misses platform data\n");
                 return -ENODEV;
         }
 
-        if (orion5x_wdt_miscdev.parent)
+        if (orion_wdt_miscdev.parent)
                 return -EBUSY;
-        orion5x_wdt_miscdev.parent = &pdev->dev;
+        orion_wdt_miscdev.parent = &pdev->dev;
 
         wdt_max_duration = WDT_MAX_CYCLE_COUNT / wdt_tclk;
-        if (orion5x_wdt_settimeout(heartbeat))
+        if (orion_wdt_settimeout(heartbeat))
                 heartbeat = wdt_max_duration;
 
-        ret = misc_register(&orion5x_wdt_miscdev);
+        ret = misc_register(&orion_wdt_miscdev);
         if (ret)
                 return ret;
 
-        printk(KERN_INFO "Orion5x Watchdog Timer: Initial timeout %d sec%s\n",
+        printk(KERN_INFO "Orion Watchdog Timer: Initial timeout %d sec%s\n",
                                 heartbeat, nowayout ? ", nowayout" : "");
         return 0;
 }
 
-static int __devexit orion5x_wdt_remove(struct platform_device *pdev)
+static int __devexit orion_wdt_remove(struct platform_device *pdev)
 {
         int ret;
 
         if (test_bit(WDT_IN_USE, &wdt_status)) {
-                orion5x_wdt_disable();
+                orion_wdt_disable();
                 clear_bit(WDT_IN_USE, &wdt_status);
         }
 
-        ret = misc_deregister(&orion5x_wdt_miscdev);
+        ret = misc_deregister(&orion_wdt_miscdev);
         if (!ret)
-                orion5x_wdt_miscdev.parent = NULL;
+                orion_wdt_miscdev.parent = NULL;
 
         return ret;
 }
 
-static void orion5x_wdt_shutdown(struct platform_device *pdev)
+static void orion_wdt_shutdown(struct platform_device *pdev)
 {
         if (test_bit(WDT_IN_USE, &wdt_status))
-                orion5x_wdt_disable();
+                orion_wdt_disable();
 }
 
-static struct platform_driver orion5x_wdt_driver = {
-        .probe          = orion5x_wdt_probe,
-        .remove         = __devexit_p(orion5x_wdt_remove),
-        .shutdown       = orion5x_wdt_shutdown,
+static struct platform_driver orion_wdt_driver = {
+        .probe          = orion_wdt_probe,
+        .remove         = __devexit_p(orion_wdt_remove),
+        .shutdown       = orion_wdt_shutdown,
         .driver         = {
                 .owner  = THIS_MODULE,
-                .name   = "orion5x_wdt",
+                .name   = "orion_wdt",
         },
 };
 
-static int __init orion5x_wdt_init(void)
+static int __init orion_wdt_init(void)
 {
         spin_lock_init(&wdt_lock);
-        return platform_driver_register(&orion5x_wdt_driver);
+        return platform_driver_register(&orion_wdt_driver);
 }
 
-static void __exit orion5x_wdt_exit(void)
+static void __exit orion_wdt_exit(void)
 {
-        platform_driver_unregister(&orion5x_wdt_driver);
+        platform_driver_unregister(&orion_wdt_driver);
 }
 
-module_init(orion5x_wdt_init);
-module_exit(orion5x_wdt_exit);
+module_init(orion_wdt_init);
+module_exit(orion_wdt_exit);
 
 MODULE_AUTHOR("Sylver Bruneau <sylver.bruneau@googlemail.com>");
-MODULE_DESCRIPTION("Orion5x Processor Watchdog");
+MODULE_DESCRIPTION("Orion Processor Watchdog");
 
 module_param(heartbeat, int, 0);
 MODULE_PARM_DESC(heartbeat, "Initial watchdog heartbeat in seconds");