1 /* 2 * drivers/watchdog/m54xx_wdt.c 3 * 4 * Watchdog driver for ColdFire MCF547x & MCF548x processors 5 * Copyright 2010 (c) Philippe De Muyter <phdm@macqel.be> 6 * 7 * Adapted from the IXP4xx watchdog driver, which carries these notices: 8 * 9 * Author: Deepak Saxena <dsaxena@plexity.net> 10 * 11 * Copyright 2004 (c) MontaVista, Software, Inc. 12 * Based on sa1100 driver, Copyright (C) 2000 Oleg Drokin <green@crimea.edu> 13 * 14 * This file is licensed under the terms of the GNU General Public 15 * License version 2. This program is licensed "as is" without any 16 * warranty of any kind, whether express or implied. 17 */ 18 19 #include <linux/module.h> 20 #include <linux/moduleparam.h> 21 #include <linux/types.h> 22 #include <linux/kernel.h> 23 #include <linux/fs.h> 24 #include <linux/miscdevice.h> 25 #include <linux/watchdog.h> 26 #include <linux/init.h> 27 #include <linux/bitops.h> 28 #include <linux/ioport.h> 29 #include <linux/uaccess.h> 30 31 #include <asm/coldfire.h> 32 #include <asm/m54xxsim.h> 33 #include <asm/m54xxgpt.h> 34 35 static int nowayout = WATCHDOG_NOWAYOUT; 36 static unsigned int heartbeat = 30; /* (secs) Default is 0.5 minute */ 37 static unsigned long wdt_status; 38 39 #define WDT_IN_USE 0 40 #define WDT_OK_TO_CLOSE 1 41 42 static void wdt_enable(void) 43 { 44 unsigned int gms0; 45 46 /* preserve GPIO usage, if any */ 47 gms0 = __raw_readl(MCF_MBAR + MCF_GPT_GMS0); 48 if (gms0 & MCF_GPT_GMS_TMS_GPIO) 49 gms0 &= (MCF_GPT_GMS_TMS_GPIO | MCF_GPT_GMS_GPIO_MASK 50 | MCF_GPT_GMS_OD); 51 else 52 gms0 = MCF_GPT_GMS_TMS_GPIO | MCF_GPT_GMS_OD; 53 __raw_writel(gms0, MCF_MBAR + MCF_GPT_GMS0); 54 __raw_writel(MCF_GPT_GCIR_PRE(heartbeat*(MCF_BUSCLK/0xffff)) | 55 MCF_GPT_GCIR_CNT(0xffff), MCF_MBAR + MCF_GPT_GCIR0); 56 gms0 |= MCF_GPT_GMS_OCPW(0xA5) | MCF_GPT_GMS_WDEN | MCF_GPT_GMS_CE; 57 __raw_writel(gms0, MCF_MBAR + MCF_GPT_GMS0); 58 } 59 60 static void wdt_disable(void) 61 { 62 unsigned int gms0; 63 64 /* disable watchdog */ 65 gms0 = __raw_readl(MCF_MBAR + MCF_GPT_GMS0); 66 gms0 &= ~(MCF_GPT_GMS_WDEN | MCF_GPT_GMS_CE); 67 __raw_writel(gms0, MCF_MBAR + MCF_GPT_GMS0); 68 } 69 70 static void wdt_keepalive(void) 71 { 72 unsigned int gms0; 73 74 gms0 = __raw_readl(MCF_MBAR + MCF_GPT_GMS0); 75 gms0 |= MCF_GPT_GMS_OCPW(0xA5); 76 __raw_writel(gms0, MCF_MBAR + MCF_GPT_GMS0); 77 } 78 79 static int m54xx_wdt_open(struct inode *inode, struct file *file) 80 { 81 if (test_and_set_bit(WDT_IN_USE, &wdt_status)) 82 return -EBUSY; 83 84 clear_bit(WDT_OK_TO_CLOSE, &wdt_status); 85 wdt_enable(); 86 return nonseekable_open(inode, file); 87 } 88 89 static ssize_t m54xx_wdt_write(struct file *file, const char *data, 90 size_t len, loff_t *ppos) 91 { 92 if (len) { 93 if (!nowayout) { 94 size_t i; 95 96 clear_bit(WDT_OK_TO_CLOSE, &wdt_status); 97 98 for (i = 0; i != len; i++) { 99 char c; 100 101 if (get_user(c, data + i)) 102 return -EFAULT; 103 if (c == 'V') 104 set_bit(WDT_OK_TO_CLOSE, &wdt_status); 105 } 106 } 107 wdt_keepalive(); 108 } 109 return len; 110 } 111 112 static const struct watchdog_info ident = { 113 .options = WDIOF_MAGICCLOSE | WDIOF_SETTIMEOUT | 114 WDIOF_KEEPALIVEPING, 115 .identity = "Coldfire M54xx Watchdog", 116 }; 117 118 static long m54xx_wdt_ioctl(struct file *file, unsigned int cmd, 119 unsigned long arg) 120 { 121 int ret = -ENOTTY; 122 int time; 123 124 switch (cmd) { 125 case WDIOC_GETSUPPORT: 126 ret = copy_to_user((struct watchdog_info *)arg, &ident, 127 sizeof(ident)) ? -EFAULT : 0; 128 break; 129 130 case WDIOC_GETSTATUS: 131 ret = put_user(0, (int *)arg); 132 break; 133 134 case WDIOC_GETBOOTSTATUS: 135 ret = put_user(0, (int *)arg); 136 break; 137 138 case WDIOC_KEEPALIVE: 139 wdt_keepalive(); 140 ret = 0; 141 break; 142 143 case WDIOC_SETTIMEOUT: 144 ret = get_user(time, (int *)arg); 145 if (ret) 146 break; 147 148 if (time <= 0 || time > 30) { 149 ret = -EINVAL; 150 break; 151 } 152 153 heartbeat = time; 154 wdt_enable(); 155 /* Fall through */ 156 157 case WDIOC_GETTIMEOUT: 158 ret = put_user(heartbeat, (int *)arg); 159 break; 160 } 161 return ret; 162 } 163 164 static int m54xx_wdt_release(struct inode *inode, struct file *file) 165 { 166 if (test_bit(WDT_OK_TO_CLOSE, &wdt_status)) 167 wdt_disable(); 168 else { 169 printk(KERN_CRIT "WATCHDOG: Device closed unexpectedly - " 170 "timer will not stop\n"); 171 wdt_keepalive(); 172 } 173 clear_bit(WDT_IN_USE, &wdt_status); 174 clear_bit(WDT_OK_TO_CLOSE, &wdt_status); 175 176 return 0; 177 } 178 179 180 static const struct file_operations m54xx_wdt_fops = { 181 .owner = THIS_MODULE, 182 .llseek = no_llseek, 183 .write = m54xx_wdt_write, 184 .unlocked_ioctl = m54xx_wdt_ioctl, 185 .open = m54xx_wdt_open, 186 .release = m54xx_wdt_release, 187 }; 188 189 static struct miscdevice m54xx_wdt_miscdev = { 190 .minor = WATCHDOG_MINOR, 191 .name = "watchdog", 192 .fops = &m54xx_wdt_fops, 193 }; 194 195 static int __init m54xx_wdt_init(void) 196 { 197 if (!request_mem_region(MCF_MBAR + MCF_GPT_GCIR0, 4, 198 "Coldfire M54xx Watchdog")) { 199 printk(KERN_WARNING 200 "Coldfire M54xx Watchdog : I/O region busy\n"); 201 return -EBUSY; 202 } 203 printk(KERN_INFO "ColdFire watchdog driver is loaded.\n"); 204 205 return misc_register(&m54xx_wdt_miscdev); 206 } 207 208 static void __exit m54xx_wdt_exit(void) 209 { 210 misc_deregister(&m54xx_wdt_miscdev); 211 release_mem_region(MCF_MBAR + MCF_GPT_GCIR0, 4); 212 } 213 214 module_init(m54xx_wdt_init); 215 module_exit(m54xx_wdt_exit); 216 217 MODULE_AUTHOR("Philippe De Muyter <phdm@macqel.be>"); 218 MODULE_DESCRIPTION("Coldfire M54xx Watchdog"); 219 220 module_param(heartbeat, int, 0); 221 MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat in seconds (default 30s)"); 222 223 module_param(nowayout, int, 0); 224 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started"); 225 226 MODULE_LICENSE("GPL"); 227 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 228