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 u8 val; 158 159 spin_lock(&io_lock); 160 161 val = __raw_readb(wdt_base); 162 val &= ~MAX6369_WDSET; 163 val |= 3; 164 __raw_writeb(val, wdt_base); 165 166 spin_unlock(&io_lock); 167 168 clear_bit(WDT_RUNNING, &wdt_status); 169 } 170 171 static int max63xx_wdt_open(struct inode *inode, struct file *file) 172 { 173 if (test_and_set_bit(WDT_IN_USE, &wdt_status)) 174 return -EBUSY; 175 176 max63xx_wdt_enable(current_timeout); 177 clear_bit(WDT_OK_TO_CLOSE, &wdt_status); 178 179 return nonseekable_open(inode, file); 180 } 181 182 static ssize_t max63xx_wdt_write(struct file *file, const char *data, 183 size_t len, loff_t *ppos) 184 { 185 if (len) { 186 if (!nowayout) { 187 size_t i; 188 189 clear_bit(WDT_OK_TO_CLOSE, &wdt_status); 190 for (i = 0; i != len; i++) { 191 char c; 192 193 if (get_user(c, data + i)) 194 return -EFAULT; 195 196 if (c == 'V') 197 set_bit(WDT_OK_TO_CLOSE, &wdt_status); 198 } 199 } 200 201 max63xx_wdt_ping(); 202 } 203 204 return len; 205 } 206 207 static const struct watchdog_info ident = { 208 .options = WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING, 209 .identity = "max63xx Watchdog", 210 }; 211 212 static long max63xx_wdt_ioctl(struct file *file, unsigned int cmd, 213 unsigned long arg) 214 { 215 int ret = -ENOTTY; 216 217 switch (cmd) { 218 case WDIOC_GETSUPPORT: 219 ret = copy_to_user((struct watchdog_info *)arg, &ident, 220 sizeof(ident)) ? -EFAULT : 0; 221 break; 222 223 case WDIOC_GETSTATUS: 224 case WDIOC_GETBOOTSTATUS: 225 ret = put_user(0, (int *)arg); 226 break; 227 228 case WDIOC_KEEPALIVE: 229 max63xx_wdt_ping(); 230 ret = 0; 231 break; 232 233 case WDIOC_GETTIMEOUT: 234 ret = put_user(heartbeat, (int *)arg); 235 break; 236 } 237 return ret; 238 } 239 240 static int max63xx_wdt_release(struct inode *inode, struct file *file) 241 { 242 if (test_bit(WDT_OK_TO_CLOSE, &wdt_status)) 243 max63xx_wdt_disable(); 244 else 245 dev_crit(&max63xx_pdev->dev, 246 "device closed unexpectedly - timer will not stop\n"); 247 248 clear_bit(WDT_IN_USE, &wdt_status); 249 clear_bit(WDT_OK_TO_CLOSE, &wdt_status); 250 251 return 0; 252 } 253 254 static const struct file_operations max63xx_wdt_fops = { 255 .owner = THIS_MODULE, 256 .llseek = no_llseek, 257 .write = max63xx_wdt_write, 258 .unlocked_ioctl = max63xx_wdt_ioctl, 259 .open = max63xx_wdt_open, 260 .release = max63xx_wdt_release, 261 }; 262 263 static struct miscdevice max63xx_wdt_miscdev = { 264 .minor = WATCHDOG_MINOR, 265 .name = "watchdog", 266 .fops = &max63xx_wdt_fops, 267 }; 268 269 static int __devinit max63xx_wdt_probe(struct platform_device *pdev) 270 { 271 int ret = 0; 272 int size; 273 struct device *dev = &pdev->dev; 274 struct max63xx_timeout *table; 275 276 table = (struct max63xx_timeout *)pdev->id_entry->driver_data; 277 278 if (heartbeat < 1 || heartbeat > MAX_HEARTBEAT) 279 heartbeat = DEFAULT_HEARTBEAT; 280 281 dev_info(dev, "requesting %ds heartbeat\n", heartbeat); 282 current_timeout = max63xx_select_timeout(table, heartbeat); 283 284 if (!current_timeout) { 285 dev_err(dev, "unable to satisfy heartbeat request\n"); 286 return -EINVAL; 287 } 288 289 dev_info(dev, "using %ds heartbeat with %ds initial delay\n", 290 current_timeout->twd, current_timeout->tdelay); 291 292 heartbeat = current_timeout->twd; 293 294 max63xx_pdev = pdev; 295 296 wdt_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); 297 if (wdt_mem == NULL) { 298 dev_err(dev, "failed to get memory region resource\n"); 299 return -ENOENT; 300 } 301 302 size = resource_size(wdt_mem); 303 if (!request_mem_region(wdt_mem->start, size, pdev->name)) { 304 dev_err(dev, "failed to get memory region\n"); 305 return -ENOENT; 306 } 307 308 wdt_base = ioremap(wdt_mem->start, size); 309 if (!wdt_base) { 310 dev_err(dev, "failed to map memory region\n"); 311 ret = -ENOMEM; 312 goto out_request; 313 } 314 315 ret = misc_register(&max63xx_wdt_miscdev); 316 if (ret < 0) { 317 dev_err(dev, "cannot register misc device\n"); 318 goto out_unmap; 319 } 320 321 return 0; 322 323 out_unmap: 324 iounmap(wdt_base); 325 out_request: 326 release_mem_region(wdt_mem->start, size); 327 wdt_mem = NULL; 328 329 return ret; 330 } 331 332 static int __devexit max63xx_wdt_remove(struct platform_device *pdev) 333 { 334 misc_deregister(&max63xx_wdt_miscdev); 335 if (wdt_mem) { 336 release_mem_region(wdt_mem->start, resource_size(wdt_mem)); 337 wdt_mem = NULL; 338 } 339 340 if (wdt_base) 341 iounmap(wdt_base); 342 343 return 0; 344 } 345 346 static struct platform_device_id max63xx_id_table[] = { 347 { "max6369_wdt", (kernel_ulong_t)max6369_table, }, 348 { "max6370_wdt", (kernel_ulong_t)max6369_table, }, 349 { "max6371_wdt", (kernel_ulong_t)max6371_table, }, 350 { "max6372_wdt", (kernel_ulong_t)max6371_table, }, 351 { "max6373_wdt", (kernel_ulong_t)max6373_table, }, 352 { "max6374_wdt", (kernel_ulong_t)max6373_table, }, 353 { }, 354 }; 355 MODULE_DEVICE_TABLE(platform, max63xx_id_table); 356 357 static struct platform_driver max63xx_wdt_driver = { 358 .probe = max63xx_wdt_probe, 359 .remove = __devexit_p(max63xx_wdt_remove), 360 .id_table = max63xx_id_table, 361 .driver = { 362 .name = "max63xx_wdt", 363 .owner = THIS_MODULE, 364 }, 365 }; 366 367 module_platform_driver(max63xx_wdt_driver); 368 369 MODULE_AUTHOR("Marc Zyngier <maz@misterjones.org>"); 370 MODULE_DESCRIPTION("max63xx Watchdog Driver"); 371 372 module_param(heartbeat, int, 0); 373 MODULE_PARM_DESC(heartbeat, 374 "Watchdog heartbeat period in seconds from 1 to " 375 __MODULE_STRING(MAX_HEARTBEAT) ", default " 376 __MODULE_STRING(DEFAULT_HEARTBEAT)); 377 378 module_param(nowayout, int, 0); 379 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" 380 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 381 382 module_param(nodelay, int, 0); 383 MODULE_PARM_DESC(nodelay, 384 "Force selection of a timeout setting without initial delay " 385 "(max6373/74 only, default=0)"); 386 387 MODULE_LICENSE("GPL"); 388 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 389