Added missing tegra files.HEADmaster

4 files changed, 1094 insertions, 0 deletions

diff --git a/drivers/watchdog/adx_wdt.c b/drivers/watchdog/adx_wdt.c
new file mode 100644
index 00000000000..af6e6b16475
--- /dev/null
+++ b/drivers/watchdog/adx_wdt.c
@@ -0,0 +1,355 @@
+/*
+ * Copyright (C) 2008-2009 Avionic Design GmbH
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/fs.h>
+#include <linux/gfp.h>
+#include <linux/io.h>
+#include <linux/miscdevice.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/types.h>
+#include <linux/uaccess.h>
+#include <linux/watchdog.h>
+
+#define WATCHDOG_NAME "adx-wdt"
+
+/* register offsets */
+#define ADX_WDT_CONTROL         0x00
+#define ADX_WDT_CONTROL_ENABLE  (1 << 0)
+#define ADX_WDT_CONTROL_nRESET  (1 << 1)
+#define ADX_WDT_TIMEOUT         0x08
+
+static struct platform_device *adx_wdt_dev;
+static unsigned long driver_open;
+
+#define WDT_STATE_STOP  0
+#define WDT_STATE_START 1
+
+struct adx_wdt {
+        void __iomem *base;
+        unsigned long timeout;
+        unsigned int state;
+        unsigned int wake;
+        spinlock_t lock;
+};
+
+static const struct watchdog_info adx_wdt_info = {
+        .identity = "Avionic Design Xanthos Watchdog",
+        .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
+};
+
+static void adx_wdt_start_locked(struct adx_wdt *wdt)
+{
+        u32 ctrl;
+
+        ctrl = readl(wdt->base + ADX_WDT_CONTROL);
+        ctrl |= ADX_WDT_CONTROL_ENABLE;
+        writel(ctrl, wdt->base + ADX_WDT_CONTROL);
+        wdt->state = WDT_STATE_START;
+}
+
+static void adx_wdt_start(struct adx_wdt *wdt)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdt->lock, flags);
+        adx_wdt_start_locked(wdt);
+        spin_unlock_irqrestore(&wdt->lock, flags);
+}
+
+static void adx_wdt_stop_locked(struct adx_wdt *wdt)
+{
+        u32 ctrl;
+
+        ctrl = readl(wdt->base + ADX_WDT_CONTROL);
+        ctrl &= ~ADX_WDT_CONTROL_ENABLE;
+        writel(ctrl, wdt->base + ADX_WDT_CONTROL);
+        wdt->state = WDT_STATE_STOP;
+}
+
+static void adx_wdt_stop(struct adx_wdt *wdt)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdt->lock, flags);
+        adx_wdt_stop_locked(wdt);
+        spin_unlock_irqrestore(&wdt->lock, flags);
+}
+
+static void adx_wdt_set_timeout(struct adx_wdt *wdt, unsigned long seconds)
+{
+        unsigned long timeout = seconds * 1000;
+        unsigned long flags;
+        unsigned int state;
+
+        spin_lock_irqsave(&wdt->lock, flags);
+        state = wdt->state;
+        adx_wdt_stop_locked(wdt);
+        writel(timeout, wdt->base + ADX_WDT_TIMEOUT);
+
+        if (state == WDT_STATE_START)
+                adx_wdt_start_locked(wdt);
+
+        wdt->timeout = timeout;
+        spin_unlock_irqrestore(&wdt->lock, flags);
+}
+
+static void adx_wdt_get_timeout(struct adx_wdt *wdt, unsigned long *seconds)
+{
+        *seconds = wdt->timeout / 1000;
+}
+
+static void adx_wdt_keepalive(struct adx_wdt *wdt)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdt->lock, flags);
+        writel(wdt->timeout, wdt->base + ADX_WDT_TIMEOUT);
+        spin_unlock_irqrestore(&wdt->lock, flags);
+}
+
+static int adx_wdt_open(struct inode *inode, struct file *file)
+{
+        struct adx_wdt *wdt = platform_get_drvdata(adx_wdt_dev);
+
+        if (test_and_set_bit(0, &driver_open))
+                return -EBUSY;
+
+        file->private_data = wdt;
+        adx_wdt_set_timeout(wdt, 30);
+        adx_wdt_start(wdt);
+
+        return nonseekable_open(inode, file);
+}
+
+static int adx_wdt_release(struct inode *inode, struct file *file)
+{
+        struct adx_wdt *wdt = file->private_data;
+
+        adx_wdt_stop(wdt);
+        clear_bit(0, &driver_open);
+
+        return 0;
+}
+
+static long adx_wdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+        struct adx_wdt *wdt = file->private_data;
+        void __user *argp = (void __user *)arg;
+        unsigned long __user *p = argp;
+        unsigned long seconds = 0;
+        unsigned int options;
+        long ret = -EINVAL;
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                if (copy_to_user(argp, &adx_wdt_info, sizeof(adx_wdt_info)))
+                        return -EFAULT;
+                else
+                        return 0;
+
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+
+        case WDIOC_KEEPALIVE:
+                adx_wdt_keepalive(wdt);
+                return 0;
+
+        case WDIOC_SETTIMEOUT:
+                if (get_user(seconds, p))
+                        return -EFAULT;
+
+                adx_wdt_set_timeout(wdt, seconds);
+
+                /* fallthrough */
+        case WDIOC_GETTIMEOUT:
+                adx_wdt_get_timeout(wdt, &seconds);
+                return put_user(seconds, p);
+
+        case WDIOC_SETOPTIONS:
+                if (copy_from_user(&options, argp, sizeof(options)))
+                        return -EFAULT;
+
+                if (options & WDIOS_DISABLECARD) {
+                        adx_wdt_stop(wdt);
+                        ret = 0;
+                }
+
+                if (options & WDIOS_ENABLECARD) {
+                        adx_wdt_start(wdt);
+                        ret = 0;
+                }
+
+                return ret;
+
+        default:
+                break;
+        }
+
+        return -ENOTTY;
+}
+
+static ssize_t adx_wdt_write(struct file *file, const char __user *data,
+                size_t len, loff_t *ppos)
+{
+        struct adx_wdt *wdt = file->private_data;
+
+        if (len)
+                adx_wdt_keepalive(wdt);
+
+        return len;
+}
+
+static const struct file_operations adx_wdt_fops = {
+        .owner = THIS_MODULE,
+        .llseek = no_llseek,
+        .open = adx_wdt_open,
+        .release = adx_wdt_release,
+        .unlocked_ioctl = adx_wdt_ioctl,
+        .write = adx_wdt_write,
+};
+
+static struct miscdevice adx_wdt_miscdev = {
+        .minor = WATCHDOG_MINOR,
+        .name = "watchdog",
+        .fops = &adx_wdt_fops,
+};
+
+static int __devinit adx_wdt_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        struct adx_wdt *wdt;
+        int ret = 0;
+        u32 ctrl;
+
+        wdt = devm_kzalloc(&pdev->dev, sizeof(*wdt), GFP_KERNEL);
+        if (!wdt) {
+                dev_err(&pdev->dev, "cannot allocate WDT structure\n");
+                return -ENOMEM;
+        }
+
+        spin_lock_init(&wdt->lock);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "cannot obtain I/O memory region\n");
+                return -ENXIO;
+        }
+
+        res = devm_request_mem_region(&pdev->dev, res->start,
+                        resource_size(res), res->name);
+        if (!res) {
+                dev_err(&pdev->dev, "cannot request I/O memory region\n");
+                return -ENXIO;
+        }
+
+        wdt->base = devm_ioremap_nocache(&pdev->dev, res->start,
+                        resource_size(res));
+        if (!wdt->base) {
+                dev_err(&pdev->dev, "cannot remap I/O memory region\n");
+                return -ENXIO;
+        }
+
+        /* disable watchdog and reboot on timeout */
+        ctrl = readl(wdt->base + ADX_WDT_CONTROL);
+        ctrl &= ~ADX_WDT_CONTROL_ENABLE;
+        ctrl &= ~ADX_WDT_CONTROL_nRESET;
+        writel(ctrl, wdt->base + ADX_WDT_CONTROL);
+
+        platform_set_drvdata(pdev, wdt);
+        adx_wdt_dev = pdev;
+
+        ret = misc_register(&adx_wdt_miscdev);
+        if (ret) {
+                dev_err(&pdev->dev, "cannot register miscdev on minor %d "
+                                "(err=%d)\n", WATCHDOG_MINOR, ret);
+                return ret;
+        }
+
+        return 0;
+}
+
+static int __devexit adx_wdt_remove(struct platform_device *pdev)
+{
+        struct adx_wdt *wdt = platform_get_drvdata(pdev);
+
+        misc_deregister(&adx_wdt_miscdev);
+        adx_wdt_stop(wdt);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static void adx_wdt_shutdown(struct platform_device *pdev)
+{
+        struct adx_wdt *wdt = platform_get_drvdata(pdev);
+        adx_wdt_stop(wdt);
+}
+
+#ifdef CONFIG_PM
+static int adx_wdt_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct adx_wdt *wdt = platform_get_drvdata(pdev);
+
+        wdt->wake = (wdt->state == WDT_STATE_START) ? 1 : 0;
+        adx_wdt_stop(wdt);
+
+        return 0;
+}
+
+static int adx_wdt_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct adx_wdt *wdt = platform_get_drvdata(pdev);
+
+        if (wdt->wake)
+                adx_wdt_start(wdt);
+
+        return 0;
+}
+
+static const struct dev_pm_ops adx_wdt_pm_ops = {
+        .suspend = adx_wdt_suspend,
+        .resume = adx_wdt_resume,
+};
+
+#  define ADX_WDT_PM_OPS        (&adx_wdt_pm_ops)
+#else
+#  define ADX_WDT_PM_OPS        NULL
+#endif
+
+static struct platform_driver adx_wdt_driver = {
+        .probe = adx_wdt_probe,
+        .remove = __devexit_p(adx_wdt_remove),
+        .shutdown = adx_wdt_shutdown,
+        .driver = {
+                .name = WATCHDOG_NAME,
+                .owner = THIS_MODULE,
+                .pm = ADX_WDT_PM_OPS,
+        },
+};
+
+static int __init adx_wdt_init(void)
+{
+        return platform_driver_register(&adx_wdt_driver);
+}
+
+static void __exit adx_wdt_exit(void)
+{
+        platform_driver_unregister(&adx_wdt_driver);
+}
+
+module_init(adx_wdt_init);
+module_exit(adx_wdt_exit);
+
+MODULE_DESCRIPTION("Avionic Design Xanthos Watchdog Driver");
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Thierry Reding <thierry.reding@avionic-design.de>");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/ixp2000_wdt.c b/drivers/watchdog/ixp2000_wdt.c
new file mode 100644
index 00000000000..e86952a7168
--- /dev/null
+++ b/drivers/watchdog/ixp2000_wdt.c
@@ -0,0 +1,215 @@
+/*
+ * drivers/char/watchdog/ixp2000_wdt.c
+ *
+ * Watchdog driver for Intel IXP2000 network processors
+ *
+ * Adapted from the IXP4xx watchdog driver by Lennert Buytenhek.
+ * The original version carries these notices:
+ *
+ * Author: Deepak Saxena <dsaxena@plexity.net>
+ *
+ * Copyright 2004 (c) MontaVista, Software, Inc.
+ * Based on sa1100 driver, Copyright (C) 2000 Oleg Drokin <green@crimea.edu>
+ *
+ * This file is licensed under  the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/types.h>
+#include <linux/timer.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/init.h>
+#include <linux/bitops.h>
+#include <linux/uaccess.h>
+#include <mach/hardware.h>
+
+static int nowayout = WATCHDOG_NOWAYOUT;
+static unsigned int heartbeat = 60;     /* (secs) Default is 1 minute */
+static unsigned long wdt_status;
+static spinlock_t wdt_lock;
+
+#define WDT_IN_USE              0
+#define WDT_OK_TO_CLOSE         1
+
+static unsigned long wdt_tick_rate;
+
+static void wdt_enable(void)
+{
+        spin_lock(&wdt_lock);
+        ixp2000_reg_write(IXP2000_RESET0, *(IXP2000_RESET0) | WDT_RESET_ENABLE);
+        ixp2000_reg_write(IXP2000_TWDE, WDT_ENABLE);
+        ixp2000_reg_write(IXP2000_T4_CLD, heartbeat * wdt_tick_rate);
+        ixp2000_reg_write(IXP2000_T4_CTL, TIMER_DIVIDER_256 | TIMER_ENABLE);
+        spin_unlock(&wdt_lock);
+}
+
+static void wdt_disable(void)
+{
+        spin_lock(&wdt_lock);
+        ixp2000_reg_write(IXP2000_T4_CTL, 0);
+        spin_unlock(&wdt_lock);
+}
+
+static void wdt_keepalive(void)
+{
+        spin_lock(&wdt_lock);
+        ixp2000_reg_write(IXP2000_T4_CLD, heartbeat * wdt_tick_rate);
+        spin_unlock(&wdt_lock);
+}
+
+static int ixp2000_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);
+
+        wdt_enable();
+
+        return nonseekable_open(inode, file);
+}
+
+static ssize_t ixp2000_wdt_write(struct file *file, const char *data,
+                                                size_t len, loff_t *ppos)
+{
+        if (len) {
+                if (!nowayout) {
+                        size_t i;
+
+                        clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
+
+                        for (i = 0; i != len; i++) {
+                                char c;
+
+                                if (get_user(c, data + i))
+                                        return -EFAULT;
+                                if (c == 'V')
+                                        set_bit(WDT_OK_TO_CLOSE, &wdt_status);
+                        }
+                }
+                wdt_keepalive();
+        }
+
+        return len;
+}
+
+
+static const struct watchdog_info ident = {
+        .options        = WDIOF_MAGICCLOSE | WDIOF_SETTIMEOUT |
+                                WDIOF_KEEPALIVEPING,
+        .identity       = "IXP2000 Watchdog",
+};
+
+static long ixp2000_wdt_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
+{
+        int ret = -ENOTTY;
+        int time;
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                ret = copy_to_user((struct watchdog_info *)arg, &ident,
+                                   sizeof(ident)) ? -EFAULT : 0;
+                break;
+
+        case WDIOC_GETSTATUS:
+                ret = put_user(0, (int *)arg);
+                break;
+
+        case WDIOC_GETBOOTSTATUS:
+                ret = put_user(0, (int *)arg);
+                break;
+
+        case WDIOC_KEEPALIVE:
+                wdt_enable();
+                ret = 0;
+                break;
+
+        case WDIOC_SETTIMEOUT:
+                ret = get_user(time, (int *)arg);
+                if (ret)
+                        break;
+
+                if (time <= 0 || time > 60) {
+                        ret = -EINVAL;
+                        break;
+                }
+
+                heartbeat = time;
+                wdt_keepalive();
+                /* Fall through */
+
+        case WDIOC_GETTIMEOUT:
+                ret = put_user(heartbeat, (int *)arg);
+                break;
+        }
+
+        return ret;
+}
+
+static int ixp2000_wdt_release(struct inode *inode, struct file *file)
+{
+        if (test_bit(WDT_OK_TO_CLOSE, &wdt_status))
+                wdt_disable();
+        else
+                printk(KERN_CRIT "WATCHDOG: Device closed unexpectedly - "
+                                        "timer will not stop\n");
+        clear_bit(WDT_IN_USE, &wdt_status);
+        clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
+
+        return 0;
+}
+
+
+static const struct file_operations ixp2000_wdt_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = ixp2000_wdt_write,
+        .unlocked_ioctl = ixp2000_wdt_ioctl,
+        .open           = ixp2000_wdt_open,
+        .release        = ixp2000_wdt_release,
+};
+
+static struct miscdevice ixp2000_wdt_miscdev = {
+        .minor          = WATCHDOG_MINOR,
+        .name           = "watchdog",
+        .fops           = &ixp2000_wdt_fops,
+};
+
+static int __init ixp2000_wdt_init(void)
+{
+        if ((*IXP2000_PRODUCT_ID & 0x001ffef0) == 0x00000000) {
+                printk(KERN_INFO "Unable to use IXP2000 watchdog due to IXP2800 erratum #25.\n");
+                return -EIO;
+        }
+        wdt_tick_rate = (*IXP2000_T1_CLD * HZ) / 256;
+        spin_lock_init(&wdt_lock);
+        return misc_register(&ixp2000_wdt_miscdev);
+}
+
+static void __exit ixp2000_wdt_exit(void)
+{
+        misc_deregister(&ixp2000_wdt_miscdev);
+}
+
+module_init(ixp2000_wdt_init);
+module_exit(ixp2000_wdt_exit);
+
+MODULE_AUTHOR("Deepak Saxena <dsaxena@plexity.net>");
+MODULE_DESCRIPTION("IXP2000 Network Processor Watchdog");
+
+module_param(heartbeat, int, 0);
+MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat in seconds (default 60s)");
+
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started");
+
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
+
diff --git a/drivers/watchdog/tegra_wdt.c b/drivers/watchdog/tegra_wdt.c
new file mode 100644
index 00000000000..4fa31b25a36
--- /dev/null
+++ b/drivers/watchdog/tegra_wdt.c
@@ -0,0 +1,491 @@
+/*
+ * drivers/watchdog/tegra_wdt.c
+ *
+ * watchdog driver for NVIDIA tegra internal watchdog
+ *
+ * Copyright (c) 2011, NVIDIA Corporation.
+ *
+ * based on drivers/watchdog/softdog.c and drivers/watchdog/omap_wdt.c
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#include <linux/fs.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/miscdevice.h>
+#include <linux/notifier.h>
+#include <linux/platform_device.h>
+#include <linux/reboot.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/uaccess.h>
+#include <linux/watchdog.h>
+
+/* minimum and maximum watchdog trigger periods, in seconds */
+#define MIN_WDT_PERIOD  5
+#define MAX_WDT_PERIOD  1000
+
+enum tegra_wdt_status {
+        WDT_DISABLED = 1 << 0,
+        WDT_ENABLED = 1 << 1,
+        WDT_IOCTL_ENABBLED_AT_PROBE = 1 << 2,
+};
+
+struct tegra_wdt {
+        struct miscdevice       miscdev;
+        struct notifier_block   notifier;
+        struct resource         *res_src;
+        struct resource         *res_wdt;
+        unsigned long           users;
+        void __iomem            *wdt_source;
+        void __iomem            *wdt_timer;
+        int                     irq;
+        int                     timeout;
+        int                     status;
+};
+
+static struct platform_device *tegra_wdt_dev;
+/*
+ * For spinlock lockup detection to work, the heartbeat should be 2*lockup
+ * for cases where the spinlock disabled irqs.
+ */
+static int heartbeat = 120; /* must be greater than MIN_WDT_PERIOD and lower than MAX_WDT_PERIOD */
+
+#if defined(CONFIG_ARCH_TEGRA_2x_SOC)
+
+#define TIMER_PTV               0x0
+ #define TIMER_EN               (1 << 31)
+ #define TIMER_PERIODIC         (1 << 30)
+#define TIMER_PCR               0x4
+ #define TIMER_PCR_INTR         (1 << 30)
+#define WDT_EN                  (1 << 5)
+#define WDT_SEL_TMR1            (0 << 4)
+#define WDT_SYS_RST             (1 << 2)
+
+static void tegra_wdt_enable(struct tegra_wdt *wdt)
+{
+        u32 val;
+
+        /* since the watchdog reset occurs when a second interrupt
+         * is asserted before the first is processed, program the
+         * timer period to one-half of the watchdog period */
+        val = wdt->timeout * 1000000ul / 2;
+        val |= (TIMER_EN | TIMER_PERIODIC);
+        writel(val, wdt->wdt_timer + TIMER_PTV);
+
+        val = WDT_EN | WDT_SEL_TMR1 | WDT_SYS_RST;
+        writel(val, wdt->wdt_source);
+}
+
+static void tegra_wdt_disable(struct tegra_wdt *wdt)
+{
+        writel(0, wdt->wdt_source);
+        writel(0, wdt->wdt_timer + TIMER_PTV);
+}
+
+static inline void tegra_wdt_ping(struct tegra_wdt *wdt)
+{
+        return;
+}
+
+static irqreturn_t tegra_wdt_interrupt(int irq, void *dev_id)
+{
+        struct tegra_wdt *wdt = dev_id;
+
+        writel(TIMER_PCR_INTR, wdt->wdt_timer + TIMER_PCR);
+        return IRQ_HANDLED;
+}
+#elif defined(CONFIG_ARCH_TEGRA_3x_SOC)
+
+#define TIMER_PTV                       0
+ #define TIMER_EN                       (1 << 31)
+ #define TIMER_PERIODIC                 (1 << 30)
+#define TIMER_PCR                       0x4
+ #define TIMER_PCR_INTR                 (1 << 30)
+#define WDT_CFG                         (0)
+ #define WDT_CFG_TMR_SRC                (0 << 0) /* for TMR10. */
+ #define WDT_CFG_PERIOD                 (1 << 4)
+ #define WDT_CFG_INT_EN                 (1 << 12)
+ #define WDT_CFG_SYS_RST_EN             (1 << 14)
+ #define WDT_CFG_PMC2CAR_RST_EN         (1 << 15)
+#define WDT_CMD                         (8)
+ #define WDT_CMD_START_COUNTER          (1 << 0)
+ #define WDT_CMD_DISABLE_COUNTER        (1 << 1)
+#define WDT_UNLOCK                      (0xC)
+ #define WDT_UNLOCK_PATTERN             (0xC45A << 0)
+
+static void tegra_wdt_set_timeout(struct tegra_wdt *wdt, int sec)
+{
+        u32 ptv;
+
+        ptv = readl(wdt->wdt_timer + TIMER_PTV);
+
+        wdt->timeout = clamp(sec, MIN_WDT_PERIOD, MAX_WDT_PERIOD);
+        if (ptv & TIMER_EN) {
+                /* since the watchdog reset occurs when a fourth interrupt
+                 * is asserted before the first is processed, program the
+                 * timer period to one-fourth of the watchdog period */
+                ptv = (wdt->timeout * 1000000ul) / 4;
+                ptv |= (TIMER_EN | TIMER_PERIODIC);
+                writel(ptv, wdt->wdt_timer + TIMER_PTV);
+        }
+}
+
+static inline void tegra_wdt_ping(struct tegra_wdt *wdt)
+{
+        writel(WDT_CMD_START_COUNTER, wdt->wdt_source + WDT_CMD);
+}
+
+static void tegra_wdt_enable(struct tegra_wdt *wdt)
+{
+        u32 val;
+
+        writel(TIMER_PCR_INTR, wdt->wdt_timer + TIMER_PCR);
+        val = (wdt->timeout * 1000000ul) / 4;
+        val |= (TIMER_EN | TIMER_PERIODIC);
+        writel(val, wdt->wdt_timer + TIMER_PTV);
+
+        val = WDT_CFG_TMR_SRC | WDT_CFG_PERIOD | /*WDT_CFG_INT_EN |*/
+                /*WDT_CFG_SYS_RST_EN |*/ WDT_CFG_PMC2CAR_RST_EN;
+        writel(val, wdt->wdt_source + WDT_CFG);
+        writel(WDT_CMD_START_COUNTER, wdt->wdt_source + WDT_CMD);
+}
+
+static void tegra_wdt_disable(struct tegra_wdt *wdt)
+{
+        writel(WDT_UNLOCK_PATTERN, wdt->wdt_source + WDT_UNLOCK);
+        writel(WDT_CMD_DISABLE_COUNTER, wdt->wdt_source + WDT_CMD);
+
+        writel(0, wdt->wdt_timer + TIMER_PTV);
+}
+
+static irqreturn_t tegra_wdt_interrupt(int irq, void *dev_id)
+{
+        struct tegra_wdt *wdt = dev_id;
+
+        tegra_wdt_ping(wdt);
+        return IRQ_HANDLED;
+}
+#endif
+
+static int tegra_wdt_notify(struct notifier_block *this,
+                            unsigned long code, void *dev)
+{
+        struct tegra_wdt *wdt = container_of(this, struct tegra_wdt, notifier);
+
+        if (code == SYS_DOWN || code == SYS_HALT)
+                tegra_wdt_disable(wdt);
+        return NOTIFY_DONE;
+}
+
+static int tegra_wdt_open(struct inode *inode, struct file *file)
+{
+        struct tegra_wdt *wdt = platform_get_drvdata(tegra_wdt_dev);
+
+        if (test_and_set_bit(1, &wdt->users))
+                return -EBUSY;
+
+        wdt->status |= WDT_ENABLED;
+        wdt->timeout = heartbeat;
+        tegra_wdt_enable(wdt);
+        file->private_data = wdt;
+        return nonseekable_open(inode, file);
+}
+
+static int tegra_wdt_release(struct inode *inode, struct file *file)
+{
+        struct tegra_wdt *wdt = file->private_data;
+
+        if (wdt->status == WDT_ENABLED) {
+#ifndef CONFIG_WATCHDOG_NOWAYOUT
+                tegra_wdt_disable(wdt);
+                wdt->status = WDT_DISABLED;
+#endif
+        }
+        wdt->users = 0;
+        return 0;
+}
+
+static long tegra_wdt_ioctl(struct file *file, unsigned int cmd,
+                            unsigned long arg)
+{
+        struct tegra_wdt *wdt = file->private_data;
+        static DEFINE_SPINLOCK(lock);
+        int new_timeout;
+        int option;
+        static const struct watchdog_info ident = {
+                .identity = "Tegra Watchdog",
+                .options = WDIOF_SETTIMEOUT,
+                .firmware_version = 0,
+        };
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                return copy_to_user((struct watchdog_info __user *)arg, &ident,
+                                    sizeof(ident));
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, (int __user *)arg);
+
+        case WDIOC_KEEPALIVE:
+                spin_lock(&lock);
+                tegra_wdt_ping(wdt);
+                spin_unlock(&lock);
+                return 0;
+
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_timeout, (int __user *)arg))
+                        return -EFAULT;
+                spin_lock(&lock);
+                tegra_wdt_disable(wdt);
+                wdt->timeout = clamp(new_timeout, MIN_WDT_PERIOD, MAX_WDT_PERIOD);
+                tegra_wdt_enable(wdt);
+                spin_unlock(&lock);
+        case WDIOC_GETTIMEOUT:
+                return put_user(wdt->timeout, (int __user *)arg);
+
+        case WDIOC_SETOPTIONS:
+#ifndef CONFIG_WATCHDOG_NOWAYOUT
+                if (get_user(option, (int __user *)arg))
+                        return -EFAULT;
+                spin_lock(&lock);
+                if (option & WDIOS_DISABLECARD) {
+                        wdt->status &= ~WDT_ENABLED;
+                        wdt->status |= WDT_DISABLED;
+                        tegra_wdt_disable(wdt);
+                } else if (option & WDIOS_ENABLECARD) {
+                        tegra_wdt_enable(wdt);
+                        wdt->status |= WDT_ENABLED;
+                        wdt->status &= ~WDT_DISABLED;
+                } else {
+                        spin_unlock(&lock);
+                        return -EINVAL;
+                }
+                spin_unlock(&lock);
+                return 0;
+#else
+                return -EINVAL;
+#endif
+        }
+        return -ENOTTY;
+}
+
+static ssize_t tegra_wdt_write(struct file *file, const char __user *data,
+                               size_t len, loff_t *ppos)
+{
+        return len;
+}
+
+static const struct file_operations tegra_wdt_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = tegra_wdt_write,
+        .unlocked_ioctl = tegra_wdt_ioctl,
+        .open           = tegra_wdt_open,
+        .release        = tegra_wdt_release,
+};
+
+static int tegra_wdt_probe(struct platform_device *pdev)
+{
+        struct resource *res_src, *res_wdt, *res_irq;
+        struct tegra_wdt *wdt;
+        u32 src;
+        int ret = 0;
+
+        if (pdev->id != -1) {
+                dev_err(&pdev->dev, "only id -1 supported\n");
+                return -ENODEV;
+        }
+
+        if (tegra_wdt_dev != NULL) {
+                dev_err(&pdev->dev, "watchdog already registered\n");
+                return -EIO;
+        }
+
+        res_src = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        res_wdt = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        res_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+
+        if (!res_src || !res_wdt || !res_irq) {
+                dev_err(&pdev->dev, "incorrect resources\n");
+                return -ENOENT;
+        }
+
+        wdt = kzalloc(sizeof(*wdt), GFP_KERNEL);
+        if (!wdt) {
+                dev_err(&pdev->dev, "out of memory\n");
+                return -ENOMEM;
+        }
+
+        wdt->irq = -1;
+        wdt->miscdev.parent = &pdev->dev;
+        wdt->miscdev.minor = WATCHDOG_MINOR;
+        wdt->miscdev.name = "watchdog";
+        wdt->miscdev.fops = &tegra_wdt_fops;
+
+        wdt->notifier.notifier_call = tegra_wdt_notify;
+
+        res_src = request_mem_region(res_src->start, resource_size(res_src),
+                                     pdev->name);
+        res_wdt = request_mem_region(res_wdt->start, resource_size(res_wdt),
+                                     pdev->name);
+
+        if (!res_src || !res_wdt) {
+                dev_err(&pdev->dev, "unable to request memory resources\n");
+                ret = -EBUSY;
+                goto fail;
+        }
+
+        wdt->wdt_source = ioremap(res_src->start, resource_size(res_src));
+        wdt->wdt_timer = ioremap(res_wdt->start, resource_size(res_wdt));
+        if (!wdt->wdt_source || !wdt->wdt_timer) {
+                dev_err(&pdev->dev, "unable to map registers\n");
+                ret = -ENOMEM;
+                goto fail;
+        }
+
+        src = readl(wdt->wdt_source);
+        if (src & BIT(12))
+                dev_info(&pdev->dev, "last reset due to watchdog timeout\n");
+
+        tegra_wdt_disable(wdt);
+        writel(TIMER_PCR_INTR, wdt->wdt_timer + TIMER_PCR);
+
+        ret = request_irq(res_irq->start, tegra_wdt_interrupt, IRQF_DISABLED,
+                          dev_name(&pdev->dev), wdt);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to configure IRQ\n");
+                goto fail;
+        }
+
+        wdt->irq = res_irq->start;
+        wdt->res_src = res_src;
+        wdt->res_wdt = res_wdt;
+
+        ret = register_reboot_notifier(&wdt->notifier);
+        if (ret) {
+                dev_err(&pdev->dev, "cannot register reboot notifier\n");
+                goto fail;
+        }
+
+        ret = misc_register(&wdt->miscdev);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register misc device\n");
+                unregister_reboot_notifier(&wdt->notifier);
+                goto fail;
+        }
+
+        platform_set_drvdata(pdev, wdt);
+        tegra_wdt_dev = pdev;
+#ifdef CONFIG_TEGRA_WATCHDOG_ENABLE_ON_PROBE
+        wdt->status = WDT_ENABLED | WDT_ENABLED_AT_PROBE;
+        wdt->timeout = heartbeat;
+        tegra_wdt_enable(wdt);
+#else
+        wdt->status = WDT_DISABLED;
+#endif
+        return 0;
+fail:
+        if (wdt->irq != -1)
+                free_irq(wdt->irq, wdt);
+        if (wdt->wdt_source)
+                iounmap(wdt->wdt_source);
+        if (wdt->wdt_timer)
+                iounmap(wdt->wdt_timer);
+        if (res_src)
+                release_mem_region(res_src->start, resource_size(res_src));
+        if (res_wdt)
+                release_mem_region(res_wdt->start, resource_size(res_wdt));
+        kfree(wdt);
+        return ret;
+}
+
+static int tegra_wdt_remove(struct platform_device *pdev)
+{
+        struct tegra_wdt *wdt = platform_get_drvdata(pdev);
+
+        tegra_wdt_disable(wdt);
+
+        unregister_reboot_notifier(&wdt->notifier);
+        misc_deregister(&wdt->miscdev);
+        free_irq(wdt->irq, wdt);
+        iounmap(wdt->wdt_source);
+        iounmap(wdt->wdt_timer);
+        release_mem_region(wdt->res_src->start, resource_size(wdt->res_src));
+        release_mem_region(wdt->res_wdt->start, resource_size(wdt->res_wdt));
+        kfree(wdt);
+        platform_set_drvdata(pdev, NULL);
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int tegra_wdt_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct tegra_wdt *wdt = platform_get_drvdata(pdev);
+
+        tegra_wdt_disable(wdt);
+        return 0;
+}
+
+static int tegra_wdt_resume(struct platform_device *pdev)
+{
+        struct tegra_wdt *wdt = platform_get_drvdata(pdev);
+
+        if (wdt->status & WDT_ENABLED)
+                tegra_wdt_enable(wdt);
+
+        return 0;
+}
+#endif
+
+static struct platform_driver tegra_wdt_driver = {
+        .probe          = tegra_wdt_probe,
+        .remove         = __devexit_p(tegra_wdt_remove),
+#ifdef CONFIG_PM
+        .suspend        = tegra_wdt_suspend,
+        .resume         = tegra_wdt_resume,
+#endif
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = "tegra_wdt",
+        },
+};
+
+static int __init tegra_wdt_init(void)
+{
+        return platform_driver_register(&tegra_wdt_driver);
+}
+
+static void __exit tegra_wdt_exit(void)
+{
+        platform_driver_unregister(&tegra_wdt_driver);
+}
+
+module_init(tegra_wdt_init);
+module_exit(tegra_wdt_exit);
+
+MODULE_AUTHOR("NVIDIA Corporation");
+MODULE_DESCRIPTION("Tegra Watchdog Driver");
+
+module_param(heartbeat, int, 0);
+MODULE_PARM_DESC(heartbeat,
+                 "Watchdog heartbeat period in seconds");
+
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
+MODULE_ALIAS("platform:tegra_wdt");
+
diff --git a/drivers/watchdog/watchdog_dev.h b/drivers/watchdog/watchdog_dev.h
new file mode 100644
index 00000000000..bc7612be25c
--- /dev/null
+++ b/drivers/watchdog/watchdog_dev.h
@@ -0,0 +1,33 @@
+/*
+ *      watchdog_core.h
+ *
+ *      (c) Copyright 2008-2011 Alan Cox <alan@lxorguk.ukuu.org.uk>,
+ *                                              All Rights Reserved.
+ *
+ *      (c) Copyright 2008-2011 Wim Van Sebroeck <wim@iguana.be>.
+ *
+ *      This source code is part of the generic code that can be used
+ *      by all the watchdog timer drivers.
+ *
+ *      Based on source code of the following authors:
+ *        Matt Domsch <Matt_Domsch@dell.com>,
+ *        Rob Radez <rob@osinvestor.com>,
+ *        Rusty Lynch <rusty@linux.co.intel.com>
+ *        Satyam Sharma <satyam@infradead.org>
+ *        Randy Dunlap <randy.dunlap@oracle.com>
+ *
+ *      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.
+ *
+ *      Neither Alan Cox, CymruNet Ltd., Wim Van Sebroeck nor Iguana vzw.
+ *      admit liability nor provide warranty for any of this software.
+ *      This material is provided "AS-IS" and at no charge.
+ */
+
+/*
+ *      Functions/procedures to be called by the core
+ */
+int watchdog_dev_register(struct watchdog_device *);
+int watchdog_dev_unregister(struct watchdog_device *);