LXR linux/drivers/watchdog/mpc5200

   1#include <linux/init.h>
   2#include <linux/module.h>
   3#include <linux/miscdevice.h>
   4#include <linux/watchdog.h>
   5#include <linux/io.h>
   6#include <linux/spinlock.h>
   7#include <linux/of_platform.h>
   8#include <linux/uaccess.h>
   9#include <asm/mpc52xx.h>
  10
  11
  12#define GPT_MODE_WDT            (1 << 15)
  13#define GPT_MODE_CE             (1 << 12)
  14#define GPT_MODE_MS_TIMER       (0x4)
  15
  16
  17struct mpc5200_wdt {
  18        unsigned count; /* timer ticks before watchdog kicks in */
  19        long ipb_freq;
  20        struct miscdevice miscdev;
  21        struct resource mem;
  22        struct mpc52xx_gpt __iomem *regs;
  23        spinlock_t io_lock;
  24};
  25
  26/* is_active stores wether or not the /dev/watchdog device is opened */
  27static unsigned long is_active;
  28
  29/* misc devices don't provide a way, to get back to 'dev' or 'miscdev' from
  30 * file operations, which sucks. But there can be max 1 watchdog anyway, so...
  31 */
  32static struct mpc5200_wdt *wdt_global;
  33
  34
  35/* helper to calculate timeout in timer counts */
  36static void mpc5200_wdt_set_timeout(struct mpc5200_wdt *wdt, int timeout)
  37{
  38        /* use biggest prescaler of 64k */
  39        wdt->count = (wdt->ipb_freq + 0xffff) / 0x10000 * timeout;
  40
  41        if (wdt->count > 0xffff)
  42                wdt->count = 0xffff;
  43}
  44/* return timeout in seconds (calculated from timer count) */
  45static int mpc5200_wdt_get_timeout(struct mpc5200_wdt *wdt)
  46{
  47        return wdt->count * 0x10000 / wdt->ipb_freq;
  48}
  49
  50
  51/* watchdog operations */
  52static int mpc5200_wdt_start(struct mpc5200_wdt *wdt)
  53{
  54        spin_lock(&wdt->io_lock);
  55        /* disable */
  56        out_be32(&wdt->regs->mode, 0);
  57        /* set timeout, with maximum prescaler */
  58        out_be32(&wdt->regs->count, 0x0 | wdt->count);
  59        /* enable watchdog */
  60        out_be32(&wdt->regs->mode, GPT_MODE_CE | GPT_MODE_WDT |
  61                                                GPT_MODE_MS_TIMER);
  62        spin_unlock(&wdt->io_lock);
  63
  64        return 0;
  65}
  66static int mpc5200_wdt_ping(struct mpc5200_wdt *wdt)
  67{
  68        spin_lock(&wdt->io_lock);
  69        /* writing A5 to OCPW resets the watchdog */
  70        out_be32(&wdt->regs->mode, 0xA5000000 |
  71                                (0xffffff & in_be32(&wdt->regs->mode)));
  72        spin_unlock(&wdt->io_lock);
  73        return 0;
  74}
  75static int mpc5200_wdt_stop(struct mpc5200_wdt *wdt)
  76{
  77        spin_lock(&wdt->io_lock);
  78        /* disable */
  79        out_be32(&wdt->regs->mode, 0);
  80        spin_unlock(&wdt->io_lock);
  81        return 0;
  82}
  83
  84
  85/* file operations */
  86static ssize_t mpc5200_wdt_write(struct file *file, const char __user *data,
  87                size_t len, loff_t *ppos)
  88{
  89        struct mpc5200_wdt *wdt = file->private_data;
  90        mpc5200_wdt_ping(wdt);
  91        return 0;
  92}
  93static struct watchdog_info mpc5200_wdt_info = {
  94        .options        = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
  95        .identity       = "mpc5200 watchdog on GPT0",
  96};
  97static long mpc5200_wdt_ioctl(struct file *file, unsigned int cmd,
  98                                                        unsigned long arg)
  99{
 100        struct mpc5200_wdt *wdt = file->private_data;
 101        int __user *data = (int __user *)arg;
 102        int timeout;
 103        int ret = 0;
 104
 105        switch (cmd) {
 106        case WDIOC_GETSUPPORT:
 107                ret = copy_to_user(data, &mpc5200_wdt_info,
 108                                                sizeof(mpc5200_wdt_info));
 109                if (ret)
 110                        ret = -EFAULT;
 111                break;
 112
 113        case WDIOC_GETSTATUS:
 114        case WDIOC_GETBOOTSTATUS:
 115                ret = put_user(0, data);
 116                break;
 117
 118        case WDIOC_KEEPALIVE:
 119                mpc5200_wdt_ping(wdt);
 120                break;
 121
 122        case WDIOC_SETTIMEOUT:
 123                ret = get_user(timeout, data);
 124                if (ret)
 125                        break;
 126                mpc5200_wdt_set_timeout(wdt, timeout);
 127                mpc5200_wdt_start(wdt);
 128                /* fall through and return the timeout */
 129
 130        case WDIOC_GETTIMEOUT:
 131                timeout = mpc5200_wdt_get_timeout(wdt);
 132                ret = put_user(timeout, data);
 133                break;
 134
 135        default:
 136                ret = -ENOTTY;
 137        }
 138        return ret;
 139}
 140
 141static int mpc5200_wdt_open(struct inode *inode, struct file *file)
 142{
 143        /* /dev/watchdog can only be opened once */
 144        if (test_and_set_bit(0, &is_active))
 145                return -EBUSY;
 146
 147        /* Set and activate the watchdog */
 148        mpc5200_wdt_set_timeout(wdt_global, 30);
 149        mpc5200_wdt_start(wdt_global);
 150        file->private_data = wdt_global;
 151        return nonseekable_open(inode, file);
 152}
 153static int mpc5200_wdt_release(struct inode *inode, struct file *file)
 154{
 155#if WATCHDOG_NOWAYOUT == 0
 156        struct mpc5200_wdt *wdt = file->private_data;
 157        mpc5200_wdt_stop(wdt);
 158        wdt->count = 0;         /* == disabled */
 159#endif
 160        clear_bit(0, &is_active);
 161        return 0;
 162}
 163
 164static const struct file_operations mpc5200_wdt_fops = {
 165        .owner  = THIS_MODULE,
 166        .write  = mpc5200_wdt_write,
 167        .unlocked_ioctl = mpc5200_wdt_ioctl,
 168        .open   = mpc5200_wdt_open,
 169        .release = mpc5200_wdt_release,
 170};
 171
 172/* module operations */
 173static int mpc5200_wdt_probe(struct of_device *op,
 174                                        const struct of_device_id *match)
 175{
 176        struct mpc5200_wdt *wdt;
 177        int err;
 178        const void *has_wdt;
 179        int size;
 180
 181        has_wdt = of_get_property(op->node, "has-wdt", NULL);
 182        if (!has_wdt)
 183                has_wdt = of_get_property(op->node, "fsl,has-wdt", NULL);
 184        if (!has_wdt)
 185                return -ENODEV;
 186
 187        wdt = kzalloc(sizeof(*wdt), GFP_KERNEL);
 188        if (!wdt)
 189                return -ENOMEM;
 190
 191        wdt->ipb_freq = mpc5xxx_get_bus_frequency(op->node);
 192
 193        err = of_address_to_resource(op->node, 0, &wdt->mem);
 194        if (err)
 195                goto out_free;
 196        size = wdt->mem.end - wdt->mem.start + 1;
 197        if (!request_mem_region(wdt->mem.start, size, "mpc5200_wdt")) {
 198                err = -ENODEV;
 199                goto out_free;
 200        }
 201        wdt->regs = ioremap(wdt->mem.start, size);
 202        if (!wdt->regs) {
 203                err = -ENODEV;
 204                goto out_release;
 205        }
 206
 207        dev_set_drvdata(&op->dev, wdt);
 208        spin_lock_init(&wdt->io_lock);
 209
 210        wdt->miscdev = (struct miscdevice) {
 211                .minor  = WATCHDOG_MINOR,
 212                .name   = "watchdog",
 213                .fops   = &mpc5200_wdt_fops,
 214                .parent = &op->dev,
 215        };
 216        wdt_global = wdt;
 217        err = misc_register(&wdt->miscdev);
 218        if (!err)
 219                return 0;
 220
 221        iounmap(wdt->regs);
 222out_release:
 223        release_mem_region(wdt->mem.start, size);
 224out_free:
 225        kfree(wdt);
 226        return err;
 227}
 228
 229static int mpc5200_wdt_remove(struct of_device *op)
 230{
 231        struct mpc5200_wdt *wdt = dev_get_drvdata(&op->dev);
 232
 233        mpc5200_wdt_stop(wdt);
 234        misc_deregister(&wdt->miscdev);
 235        iounmap(wdt->regs);
 236        release_mem_region(wdt->mem.start, wdt->mem.end - wdt->mem.start + 1);
 237        kfree(wdt);
 238
 239        return 0;
 240}
 241static int mpc5200_wdt_suspend(struct of_device *op, pm_message_t state)
 242{
 243        struct mpc5200_wdt *wdt = dev_get_drvdata(&op->dev);
 244        mpc5200_wdt_stop(wdt);
 245        return 0;
 246}
 247static int mpc5200_wdt_resume(struct of_device *op)
 248{
 249        struct mpc5200_wdt *wdt = dev_get_drvdata(&op->dev);
 250        if (wdt->count)
 251                mpc5200_wdt_start(wdt);
 252        return 0;
 253}
 254static int mpc5200_wdt_shutdown(struct of_device *op)
 255{
 256        struct mpc5200_wdt *wdt = dev_get_drvdata(&op->dev);
 257        mpc5200_wdt_stop(wdt);
 258        return 0;
 259}
 260
 261static struct of_device_id mpc5200_wdt_match[] = {
 262        { .compatible = "mpc5200-gpt", },
 263        { .compatible = "fsl,mpc5200-gpt", },
 264        {},
 265};
 266static struct of_platform_driver mpc5200_wdt_driver = {
 267        .owner          = THIS_MODULE,
 268        .name           = "mpc5200-gpt-wdt",
 269        .match_table    = mpc5200_wdt_match,
 270        .probe          = mpc5200_wdt_probe,
 271        .remove         = mpc5200_wdt_remove,
 272        .suspend        = mpc5200_wdt_suspend,
 273        .resume         = mpc5200_wdt_resume,
 274        .shutdown       = mpc5200_wdt_shutdown,
 275};
 276
 277
 278static int __init mpc5200_wdt_init(void)
 279{
 280        return of_register_platform_driver(&mpc5200_wdt_driver);
 281}
 282
 283static void __exit mpc5200_wdt_exit(void)
 284{
 285        of_unregister_platform_driver(&mpc5200_wdt_driver);
 286}
 287
 288module_init(mpc5200_wdt_init);
 289module_exit(mpc5200_wdt_exit);
 290
 291MODULE_AUTHOR("Domen Puncer <domen.puncer@telargo.com>");
 292MODULE_LICENSE("Dual BSD/GPL");
 293MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 294