drivers/watchdog/sb_wdog.c

   1 /*
   2  * Watchdog driver for SiByte SB1 SoCs
   3  *
   4  * Copyright (C) 2007 OnStor, Inc. * Andrew Sharp <andy.sharp@onstor.com>
   5  *
   6  * This driver is intended to make the second of two hardware watchdogs
   7  * on the Sibyte 12XX and 11XX SoCs available to the user.  There are two
   8  * such devices available on the SoC, but it seems that there isn't an
   9  * enumeration class for watchdogs in Linux like there is for RTCs.
  10  * The second is used rather than the first because it uses IRQ 1,
  11  * thereby avoiding all that IRQ 0 problematic nonsense.
  12  *
  13  * I have not tried this driver on a 1480 processor; it might work
  14  * just well enough to really screw things up.
  15  *
  16  * It is a simple timer, and there is an interrupt that is raised the
  17  * first time the timer expires.  The second time it expires, the chip
  18  * is reset and there is no way to redirect that NMI.  Which could
  19  * be problematic in some cases where this chip is sitting on the HT
  20  * bus and has just taken responsibility for providing a cache block.
  21  * Since the reset can't be redirected to the external reset pin, it is
  22  * possible that other HT connected processors might hang and not reset.
  23  * For Linux, a soft reset would probably be even worse than a hard reset.
  24  * There you have it.
  25  *
  26  * The timer takes 23 bits of a 64 bit register (?) as a count value,
  27  * and decrements the count every microsecond, for a max value of
  28  * 0x7fffff usec or about 8.3ish seconds.
  29  *
  30  * This watchdog borrows some user semantics from the softdog driver,
  31  * in that if you close the fd, it leaves the watchdog running, unless
  32  * you previously wrote a 'V' to the fd, in which case it disables
  33  * the watchdog when you close the fd like some other drivers.
  34  *
  35  * Based on various other watchdog drivers, which are probably all
  36  * loosely based on something Alan Cox wrote years ago.
  37  *
  38  *      (c) Copyright 1996 Alan Cox <alan@redhat.com>, All Rights Reserved.
  39  *                              http://www.redhat.com
  40  *
  41  *      This program is free software; you can redistribute it and/or
  42  *      modify it under the terms of the GNU General Public License
  43  *      version 1 or 2 as published by the Free Software Foundation.
  44  *
  45  */
  46 #include <linux/module.h>
  47 #include <linux/io.h>
  48 #include <linux/uaccess.h>
  49 #include <linux/fs.h>
  50 #include <linux/reboot.h>
  51 #include <linux/miscdevice.h>
  52 #include <linux/watchdog.h>
  53 #include <linux/interrupt.h>
  54
  55 #include <asm/sibyte/sb1250.h>
  56 #include <asm/sibyte/sb1250_regs.h>
  57 #include <asm/sibyte/sb1250_int.h>
  58 #include <asm/sibyte/sb1250_scd.h>
  59
  60
  61 /*
  62  * set the initial count value of a timer
  63  *
  64  * wdog is the iomem address of the cfg register
  65  */
  66 void sbwdog_set(char __iomem *wdog, unsigned long t)
  67 {
  68         __raw_writeb(0, wdog - 0x10);
  69         __raw_writeq(t & 0x7fffffUL, wdog);
  70 }
  71
  72 /*
  73  * cause the timer to [re]load it's initial count and start counting
  74  * all over again
  75  *
  76  * wdog is the iomem address of the cfg register
  77  */
  78 void sbwdog_pet(char __iomem *wdog)
  79 {
  80         __raw_writeb(__raw_readb(wdog) | 1, wdog);
  81 }
  82
  83 static unsigned long sbwdog_gate; /* keeps it to one thread only */
  84 static char __iomem *kern_dog = (char __iomem *)(IO_BASE + (A_SCD_WDOG_CFG_0));
  85 static char __iomem *user_dog = (char __iomem *)(IO_BASE + (A_SCD_WDOG_CFG_1));
  86 static unsigned long timeout = 0x7fffffUL;      /* useconds: 8.3ish secs. */
  87 static int expect_close;
  88
  89 static struct watchdog_info ident = {
  90         .options        = WDIOF_CARDRESET | WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
  91         .identity       = "SiByte Watchdog",
  92 };
  93
  94 /*
  95  * Allow only a single thread to walk the dog
  96  */
  97 static int sbwdog_open(struct inode *inode, struct file *file)
  98 {
  99         nonseekable_open(inode, file);
 100         if (test_and_set_bit(0, &sbwdog_gate)) {
 101                 return -EBUSY;
 102         }
 103         __module_get(THIS_MODULE);
 104
 105         /*
 106          * Activate the timer
 107          */
 108         sbwdog_set(user_dog, timeout);
 109         __raw_writeb(1, user_dog);
 110
 111         return 0;
 112 }
 113
 114 /*
 115  * Put the dog back in the kennel.
 116  */
 117 static int sbwdog_release(struct inode *inode, struct file *file)
 118 {
 119         if (expect_close == 42) {
 120                 __raw_writeb(0, user_dog);
 121                 module_put(THIS_MODULE);
 122         } else {
 123                 printk(KERN_CRIT "%s: Unexpected close, not stopping watchdog!\n",
 124                         ident.identity);
 125                 sbwdog_pet(user_dog);
 126         }
 127         clear_bit(0, &sbwdog_gate);
 128         expect_close = 0;
 129
 130         return 0;
 131 }
 132
 133 /*
 134  * 42 - the answer
 135  */
 136 static ssize_t sbwdog_write(struct file *file, const char __user *data,
 137                         size_t len, loff_t *ppos)
 138 {
 139         int i;
 140
 141         if (len) {
 142                 /*
 143                  * restart the timer
 144                  */
 145                 expect_close = 0;
 146
 147                 for (i = 0; i != len; i++) {
 148                         char c;
 149
 150                         if (get_user(c, data + i)) {
 151                                 return -EFAULT;
 152                         }
 153                         if (c == 'V') {
 154                                 expect_close = 42;
 155                         }
 156                 }
 157                 sbwdog_pet(user_dog);
 158         }
 159
 160         return len;
 161 }
 162
 163 static int sbwdog_ioctl(struct inode *inode, struct file *file,
 164                         unsigned int cmd, unsigned long arg)
 165 {
 166         int ret = -ENOTTY;
 167         unsigned long time;
 168         void __user *argp = (void __user *)arg;
 169         int __user *p = argp;
 170
 171         switch (cmd) {
 172         case WDIOC_GETSUPPORT:
 173                 ret = copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
 174                 break;
 175
 176         case WDIOC_GETSTATUS:
 177         case WDIOC_GETBOOTSTATUS:
 178                 ret = put_user(0, p);
 179                 break;
 180
 181         case WDIOC_SETTIMEOUT:
 182                 ret = get_user(time, p);
 183                 if (ret) {
 184                         break;
 185                 }
 186
 187                 time *= 1000000;
 188                 if (time > 0x7fffffUL) {
 189                         ret = -EINVAL;
 190                         break;
 191                 }
 192                 timeout = time;
 193                 sbwdog_set(user_dog, timeout);
 194                 sbwdog_pet(user_dog);
 195
 196         case WDIOC_GETTIMEOUT:
 197                 /*
 198                  * get the remaining count from the ... count register
 199                  * which is 1*8 before the config register
 200                  */
 201                 ret = put_user(__raw_readq(user_dog - 8) / 1000000, p);
 202                 break;
 203
 204         case WDIOC_KEEPALIVE:
 205                 sbwdog_pet(user_dog);
 206                 ret = 0;
 207                 break;
 208         }
 209         return ret;
 210 }
 211
 212 /*
 213  *      Notifier for system down
 214  */
 215 static int
 216 sbwdog_notify_sys(struct notifier_block *this, unsigned long code, void *erf)
 217 {
 218         if (code == SYS_DOWN || code == SYS_HALT) {
 219                 /*
 220                  * sit and sit
 221                  */
 222                 __raw_writeb(0, user_dog);
 223                 __raw_writeb(0, kern_dog);
 224         }
 225
 226         return NOTIFY_DONE;
 227 }
 228
 229 static const struct file_operations sbwdog_fops =
 230 {
 231         .owner          = THIS_MODULE,
 232         .llseek         = no_llseek,
 233         .write          = sbwdog_write,
 234         .ioctl          = sbwdog_ioctl,
 235         .open           = sbwdog_open,
 236         .release        = sbwdog_release,
 237 };
 238
 239 static struct miscdevice sbwdog_miscdev =
 240 {
 241         .minor          = WATCHDOG_MINOR,
 242         .name           = "watchdog",
 243         .fops           = &sbwdog_fops,
 244 };
 245
 246 static struct notifier_block sbwdog_notifier = {
 247         .notifier_call  = sbwdog_notify_sys,
 248 };
 249
 250 /*
 251  * interrupt handler
 252  *
 253  * doesn't do a whole lot for user, but oh so cleverly written so kernel
 254  * code can use it to re-up the watchdog, thereby saving the kernel from
 255  * having to create and maintain a timer, just to tickle another timer,
 256  * which is just so wrong.
 257  */
 258 irqreturn_t sbwdog_interrupt(int irq, void *addr)
 259 {
 260         unsigned long wd_init;
 261         char *wd_cfg_reg = (char *)addr;
 262         u8 cfg;
 263
 264         cfg = __raw_readb(wd_cfg_reg);
 265         wd_init = __raw_readq(wd_cfg_reg - 8) & 0x7fffff;
 266
 267         /*
 268          * if it's the second watchdog timer, it's for those users
 269          */
 270         if (wd_cfg_reg == user_dog) {
 271                 printk(KERN_CRIT
 272                         "%s in danger of initiating system reset in %ld.%01ld seconds\n",
 273                         ident.identity, wd_init / 1000000, (wd_init / 100000) % 10);
 274         } else {
 275                 cfg |= 1;
 276         }
 277
 278         __raw_writeb(cfg, wd_cfg_reg);
 279
 280         return IRQ_HANDLED;
 281 }
 282
 283 static int __init sbwdog_init(void)
 284 {
 285         int ret;
 286
 287         /*
 288          * register a reboot notifier
 289          */
 290         ret = register_reboot_notifier(&sbwdog_notifier);
 291         if (ret) {
 292                 printk (KERN_ERR "%s: cannot register reboot notifier (err=%d)\n",
 293                         ident.identity, ret);
 294                 return ret;
 295         }
 296
 297         /*
 298          * get the resources
 299          */
 300         ret = misc_register(&sbwdog_miscdev);
 301         if (ret == 0) {
 302                 printk(KERN_INFO "%s: timeout is %ld.%ld secs\n", ident.identity,
 303                         timeout / 1000000, (timeout / 100000) % 10);
 304         }
 305
 306         ret = request_irq(1, sbwdog_interrupt, IRQF_DISABLED | IRQF_SHARED,
 307                 ident.identity, (void *)user_dog);
 308         if (ret) {
 309                 printk(KERN_ERR "%s: failed to request irq 1 - %d\n", ident.identity,
 310                         ret);
 311                 misc_deregister(&sbwdog_miscdev);
 312         }
 313
 314         return ret;
 315 }
 316
 317 static void __exit sbwdog_exit(void)
 318 {
 319         misc_deregister(&sbwdog_miscdev);
 320 }
 321
 322 module_init(sbwdog_init);
 323 module_exit(sbwdog_exit);
 324
 325 MODULE_AUTHOR("Andrew Sharp <andy.sharp@onstor.com>");
 326 MODULE_DESCRIPTION("SiByte Watchdog");
 327
 328 module_param(timeout, ulong, 0);
 329 MODULE_PARM_DESC(timeout,
 330         "Watchdog timeout in microseconds (max/default 8388607 or 8.3ish secs)");
 331
 332 MODULE_LICENSE("GPL");
 333 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 334
 335 /*
 336  * example code that can be put in a platform code area to utilize the
 337  * first watchdog timer for the kernels own purpose.
 338
 339  void
 340 platform_wd_setup(void)
 341 {
 342         int ret;
 343
 344         ret = request_irq(0, sbwdog_interrupt, IRQF_DISABLED | IRQF_SHARED,
 345                 "Kernel Watchdog", IOADDR(A_SCD_WDOG_CFG_0));
 346         if (ret) {
 347                 printk(KERN_CRIT "Watchdog IRQ zero(0) failed to be requested - %d\n",
 348                         ret);
 349         }
 350 }
 351
 352
 353  */