SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/watchdog/max63xx_wdt.c

   1 /*
   2  * drivers/char/watchdog/max63xx_wdt.c
   3  *
   4  * Driver for max63{69,70,71,72,73,74} watchdog timers
   5  *
   6  * Copyright (C) 2009 Marc Zyngier <maz@misterjones.org>
   7  *
   8  * This file is licensed under the terms of the GNU General Public
   9  * License version 2. This program is licensed "as is" without any
  10  * warranty of any kind, whether express or implied.
  11  *
  12  * This driver assumes the watchdog pins are memory mapped (as it is
  13  * the case for the Arcom Zeus). Should it be connected over GPIOs or
  14  * another interface, some abstraction will have to be introduced.
  15  */
  16
  17 #include <linux/module.h>
  18 #include <linux/moduleparam.h>
  19 #include <linux/types.h>
  20 #include <linux/kernel.h>
  21 #include <linux/fs.h>
  22 #include <linux/miscdevice.h>
  23 #include <linux/watchdog.h>
  24 #include <linux/init.h>
  25 #include <linux/bitops.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/spinlock.h>
  28 #include <linux/uaccess.h>
  29 #include <linux/io.h>
  30 #include <linux/device.h>
  31 #include <linux/slab.h>
  32
  33 #define DEFAULT_HEARTBEAT 60
  34 #define MAX_HEARTBEAT     60
  35
  36 static int heartbeat = DEFAULT_HEARTBEAT;
  37 static int nowayout  = WATCHDOG_NOWAYOUT;
  38
  39 /*
  40  * Memory mapping: a single byte, 3 first lower bits to select bit 3
  41  * to ping the watchdog.
  42  */
  43 #define MAX6369_WDSET   (7 << 0)
  44 #define MAX6369_WDI     (1 << 3)
  45
  46 static DEFINE_SPINLOCK(io_lock);
  47
  48 static unsigned long wdt_status;
  49 #define WDT_IN_USE      0
  50 #define WDT_RUNNING     1
  51 #define WDT_OK_TO_CLOSE 2
  52
  53 static int nodelay;
  54 static struct resource  *wdt_mem;
  55 static void __iomem     *wdt_base;
  56 static struct platform_device *max63xx_pdev;
  57
  58 /*
  59  * The timeout values used are actually the absolute minimum the chip
  60  * offers. Typical values on my board are slightly over twice as long
  61  * (10s setting ends up with a 25s timeout), and can be up to 3 times
  62  * the nominal setting (according to the datasheet). So please take
  63  * these values with a grain of salt. Same goes for the initial delay
  64  * "feature". Only max6373/74 have a few settings without this initial
  65  * delay (selected with the "nodelay" parameter).
  66  *
  67  * I also decided to remove from the tables any timeout smaller than a
  68  * second, as it looked completly overkill...
  69  */
  70
  71 /* Timeouts in second */
  72 struct max63xx_timeout {
  73         u8 wdset;
  74         u8 tdelay;
  75         u8 twd;
  76 };
  77
  78 static struct max63xx_timeout max6369_table[] = {
  79         { 5,  1,  1 },
  80         { 6, 10, 10 },
  81         { 7, 60, 60 },
  82         { },
  83 };
  84
  85 static struct max63xx_timeout max6371_table[] = {
  86         { 6, 60,  3 },
  87         { 7, 60, 60 },
  88         { },
  89 };
  90
  91 static struct max63xx_timeout max6373_table[] = {
  92         { 2, 60,  1 },
  93         { 5,  0,  1 },
  94         { 1,  3,  3 },
  95         { 7, 60, 10 },
  96         { 6,  0, 10 },
  97         { },
  98 };
  99
 100 static struct max63xx_timeout *current_timeout;
 101
 102 static struct max63xx_timeout *
 103 max63xx_select_timeout(struct max63xx_timeout *table, int value)
 104 {
 105         while (table->twd) {
 106                 if (value <= table->twd) {
 107                         if (nodelay && table->tdelay == 0)
 108                                 return table;
 109
 110                         if (!nodelay)
 111                                 return table;
 112                 }
 113
 114                 table++;
 115         }
 116
 117         return NULL;
 118 }
 119
 120 static void max63xx_wdt_ping(void)
 121 {
 122         u8 val;
 123
 124         spin_lock(&io_lock);
 125
 126         val = __raw_readb(wdt_base);
 127
 128         __raw_writeb(val | MAX6369_WDI, wdt_base);
 129         __raw_writeb(val & ~MAX6369_WDI, wdt_base);
 130
 131         spin_unlock(&io_lock);
 132 }
 133
 134 static void max63xx_wdt_enable(struct max63xx_timeout *entry)
 135 {
 136         u8 val;
 137
 138         if (test_and_set_bit(WDT_RUNNING, &wdt_status))
 139                 return;
 140
 141         spin_lock(&io_lock);
 142
 143         val = __raw_readb(wdt_base);
 144         val &= ~MAX6369_WDSET;
 145         val |= entry->wdset;
 146         __raw_writeb(val, wdt_base);
 147
 148         spin_unlock(&io_lock);
 149
 150         /* check for a edge triggered startup */
 151         if (entry->tdelay == 0)
 152                 max63xx_wdt_ping();
 153 }
 154
 155 static void max63xx_wdt_disable(void)
 156 {
 157         spin_lock(&io_lock);
 158
 159         __raw_writeb(3, wdt_base);
 160
 161         spin_unlock(&io_lock);
 162
 163         clear_bit(WDT_RUNNING, &wdt_status);
 164 }
 165
 166 static int max63xx_wdt_open(struct inode *inode, struct file *file)
 167 {
 168         if (test_and_set_bit(WDT_IN_USE, &wdt_status))
 169                 return -EBUSY;
 170
 171         max63xx_wdt_enable(current_timeout);
 172         clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
 173
 174         return nonseekable_open(inode, file);
 175 }
 176
 177 static ssize_t max63xx_wdt_write(struct file *file, const char *data,
 178                                  size_t len, loff_t *ppos)
 179 {
 180         if (len) {
 181                 if (!nowayout) {
 182                         size_t i;
 183
 184                         clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
 185                         for (i = 0; i != len; i++) {
 186                                 char c;
 187
 188                                 if (get_user(c, data + i))
 189                                         return -EFAULT;
 190
 191                                 if (c == 'V')
 192                                         set_bit(WDT_OK_TO_CLOSE, &wdt_status);
 193                         }
 194                 }
 195
 196                 max63xx_wdt_ping();
 197         }
 198
 199         return len;
 200 }
 201
 202 static const struct watchdog_info ident = {
 203         .options = WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING,
 204         .identity = "max63xx Watchdog",
 205 };
 206
 207 static long max63xx_wdt_ioctl(struct file *file, unsigned int cmd,
 208                               unsigned long arg)
 209 {
 210         int ret = -ENOTTY;
 211
 212         switch (cmd) {
 213         case WDIOC_GETSUPPORT:
 214                 ret = copy_to_user((struct watchdog_info *)arg, &ident,
 215                                    sizeof(ident)) ? -EFAULT : 0;
 216                 break;
 217
 218         case WDIOC_GETSTATUS:
 219         case WDIOC_GETBOOTSTATUS:
 220                 ret = put_user(0, (int *)arg);
 221                 break;
 222
 223         case WDIOC_KEEPALIVE:
 224                 max63xx_wdt_ping();
 225                 ret = 0;
 226                 break;
 227
 228         case WDIOC_GETTIMEOUT:
 229                 ret = put_user(heartbeat, (int *)arg);
 230                 break;
 231         }
 232         return ret;
 233 }
 234
 235 static int max63xx_wdt_release(struct inode *inode, struct file *file)
 236 {
 237         if (test_bit(WDT_OK_TO_CLOSE, &wdt_status))
 238                 max63xx_wdt_disable();
 239         else
 240                 dev_crit(&max63xx_pdev->dev,
 241                          "device closed unexpectedly - timer will not stop\n");
 242
 243         clear_bit(WDT_IN_USE, &wdt_status);
 244         clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
 245
 246         return 0;
 247 }
 248
 249 static const struct file_operations max63xx_wdt_fops = {
 250         .owner          = THIS_MODULE,
 251         .llseek         = no_llseek,
 252         .write          = max63xx_wdt_write,
 253         .unlocked_ioctl = max63xx_wdt_ioctl,
 254         .open           = max63xx_wdt_open,
 255         .release        = max63xx_wdt_release,
 256 };
 257
 258 static struct miscdevice max63xx_wdt_miscdev = {
 259         .minor  = WATCHDOG_MINOR,
 260         .name   = "watchdog",
 261         .fops   = &max63xx_wdt_fops,
 262 };
 263
 264 static int __devinit max63xx_wdt_probe(struct platform_device *pdev)
 265 {
 266         int ret = 0;
 267         int size;
 268         struct resource *res;
 269         struct device *dev = &pdev->dev;
 270         struct max63xx_timeout *table;
 271
 272         table = (struct max63xx_timeout *)pdev->id_entry->driver_data;
 273
 274         if (heartbeat < 1 || heartbeat > MAX_HEARTBEAT)
 275                 heartbeat = DEFAULT_HEARTBEAT;
 276
 277         dev_info(dev, "requesting %ds heartbeat\n", heartbeat);
 278         current_timeout = max63xx_select_timeout(table, heartbeat);
 279
 280         if (!current_timeout) {
 281                 dev_err(dev, "unable to satisfy heartbeat request\n");
 282                 return -EINVAL;
 283         }
 284
 285         dev_info(dev, "using %ds heartbeat with %ds initial delay\n",
 286                  current_timeout->twd, current_timeout->tdelay);
 287
 288         heartbeat = current_timeout->twd;
 289
 290         max63xx_pdev = pdev;
 291
 292         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 293         if (res == NULL) {
 294                 dev_err(dev, "failed to get memory region resource\n");
 295                 return -ENOENT;
 296         }
 297
 298         size = resource_size(res);
 299         wdt_mem = request_mem_region(res->start, size, pdev->name);
 300
 301         if (wdt_mem == NULL) {
 302                 dev_err(dev, "failed to get memory region\n");
 303                 return -ENOENT;
 304         }
 305
 306         wdt_base = ioremap(res->start, size);
 307         if (!wdt_base) {
 308                 dev_err(dev, "failed to map memory region\n");
 309                 ret = -ENOMEM;
 310                 goto out_request;
 311         }
 312
 313         ret = misc_register(&max63xx_wdt_miscdev);
 314         if (ret < 0) {
 315                 dev_err(dev, "cannot register misc device\n");
 316                 goto out_unmap;
 317         }
 318
 319         return 0;
 320
 321 out_unmap:
 322         iounmap(wdt_base);
 323 out_request:
 324         release_resource(wdt_mem);
 325         kfree(wdt_mem);
 326
 327         return ret;
 328 }
 329
 330 static int __devexit max63xx_wdt_remove(struct platform_device *pdev)
 331 {
 332         misc_deregister(&max63xx_wdt_miscdev);
 333         if (wdt_mem) {
 334                 release_resource(wdt_mem);
 335                 kfree(wdt_mem);
 336                 wdt_mem = NULL;
 337         }
 338
 339         if (wdt_base)
 340                 iounmap(wdt_base);
 341
 342         return 0;
 343 }
 344
 345 static struct platform_device_id max63xx_id_table[] = {
 346         { "max6369_wdt", (kernel_ulong_t)max6369_table, },
 347         { "max6370_wdt", (kernel_ulong_t)max6369_table, },
 348         { "max6371_wdt", (kernel_ulong_t)max6371_table, },
 349         { "max6372_wdt", (kernel_ulong_t)max6371_table, },
 350         { "max6373_wdt", (kernel_ulong_t)max6373_table, },
 351         { "max6374_wdt", (kernel_ulong_t)max6373_table, },
 352         { },
 353 };
 354 MODULE_DEVICE_TABLE(platform, max63xx_id_table);
 355
 356 static struct platform_driver max63xx_wdt_driver = {
 357         .probe          = max63xx_wdt_probe,
 358         .remove         = __devexit_p(max63xx_wdt_remove),
 359         .id_table       = max63xx_id_table,
 360         .driver         = {
 361                 .name   = "max63xx_wdt",
 362                 .owner  = THIS_MODULE,
 363         },
 364 };
 365
 366 static int __init max63xx_wdt_init(void)
 367 {
 368         return platform_driver_register(&max63xx_wdt_driver);
 369 }
 370
 371 static void __exit max63xx_wdt_exit(void)
 372 {
 373         platform_driver_unregister(&max63xx_wdt_driver);
 374 }
 375
 376 module_init(max63xx_wdt_init);
 377 module_exit(max63xx_wdt_exit);
 378
 379 MODULE_AUTHOR("Marc Zyngier <maz@misterjones.org>");
 380 MODULE_DESCRIPTION("max63xx Watchdog Driver");
 381
 382 module_param(heartbeat, int, 0);
 383 MODULE_PARM_DESC(heartbeat,
 384                  "Watchdog heartbeat period in seconds from 1 to "
 385                  __MODULE_STRING(MAX_HEARTBEAT) ", default "
 386                  __MODULE_STRING(DEFAULT_HEARTBEAT));
 387
 388 module_param(nowayout, int, 0);
 389 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
 390                  __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 391
 392 module_param(nodelay, int, 0);
 393 MODULE_PARM_DESC(nodelay,
 394                  "Force selection of a timeout setting without initial delay "
 395                  "(max6373/74 only, default=0)");
 396
 397 MODULE_LICENSE("GPL");
 398 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);