drivers/watchdog/mpc5200_wdt.c

   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
  17 struct 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 */
  27 static 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  */
  32 static struct mpc5200_wdt *wdt_global;
  33
  34
  35 /* helper to calculate timeout in timer counts */
  36 static 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) */
  45 static int mpc5200_wdt_get_timeout(struct mpc5200_wdt *wdt)
  46 {
  47         return wdt->count * 0x10000 / wdt->ipb_freq;
  48 }
  49
  50
  51 /* watchdog operations */
  52 static 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 }
  66 static 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 }
  75 static 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 */
  86 static 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 }
  93 static struct watchdog_info mpc5200_wdt_info = {
  94         .options        = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
  95         .identity       = "mpc5200 watchdog on GPT0",
  96 };
  97 static 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
 141 static 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 }
 153 static 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
 164 static 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 */
 173 static 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 = mpc52xx_find_ipb_freq(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);
 222 out_release:
 223         release_mem_region(wdt->mem.start, size);
 224 out_free:
 225         kfree(wdt);
 226         return err;
 227 }
 228
 229 static 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 }
 241 static 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 }
 247 static 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 }
 254 static 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
 261 static struct of_device_id mpc5200_wdt_match[] = {
 262         { .compatible = "mpc5200-gpt", },
 263         { .compatible = "fsl,mpc5200-gpt", },
 264         {},
 265 };
 266 static 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
 278 static int __init mpc5200_wdt_init(void)
 279 {
 280         return of_register_platform_driver(&mpc5200_wdt_driver);
 281 }
 282
 283 static void __exit mpc5200_wdt_exit(void)
 284 {
 285         of_unregister_platform_driver(&mpc5200_wdt_driver);
 286 }
 287
 288 module_init(mpc5200_wdt_init);
 289 module_exit(mpc5200_wdt_exit);
 290
 291 MODULE_AUTHOR("Domen Puncer <domen.puncer@telargo.com>");
 292 MODULE_LICENSE("Dual BSD/GPL");
 293 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);