wm831x_wdt.c (6ad390a25a9d1d8606b9b826878f0a30639dc2b3) | wm831x_wdt.c (00411ee9308e4b5f4b04caaa01685f955e259373) |
---|---|
1/* 2 * Watchdog driver for the wm831x PMICs 3 * 4 * Copyright (C) 2009 Wolfson Microelectronics 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation 9 */ 10 11#include <linux/module.h> 12#include <linux/moduleparam.h> 13#include <linux/types.h> 14#include <linux/kernel.h> | 1/* 2 * Watchdog driver for the wm831x PMICs 3 * 4 * Copyright (C) 2009 Wolfson Microelectronics 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation 9 */ 10 11#include <linux/module.h> 12#include <linux/moduleparam.h> 13#include <linux/types.h> 14#include <linux/kernel.h> |
15#include <linux/fs.h> 16#include <linux/miscdevice.h> | 15#include <linux/slab.h> |
17#include <linux/platform_device.h> 18#include <linux/watchdog.h> 19#include <linux/uaccess.h> 20#include <linux/gpio.h> 21 22#include <linux/mfd/wm831x/core.h> 23#include <linux/mfd/wm831x/pdata.h> 24#include <linux/mfd/wm831x/watchdog.h> 25 26static int nowayout = WATCHDOG_NOWAYOUT; 27module_param(nowayout, int, 0); 28MODULE_PARM_DESC(nowayout, 29 "Watchdog cannot be stopped once started (default=" 30 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 31 | 16#include <linux/platform_device.h> 17#include <linux/watchdog.h> 18#include <linux/uaccess.h> 19#include <linux/gpio.h> 20 21#include <linux/mfd/wm831x/core.h> 22#include <linux/mfd/wm831x/pdata.h> 23#include <linux/mfd/wm831x/watchdog.h> 24 25static int nowayout = WATCHDOG_NOWAYOUT; 26module_param(nowayout, int, 0); 27MODULE_PARM_DESC(nowayout, 28 "Watchdog cannot be stopped once started (default=" 29 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 30 |
32static unsigned long wm831x_wdt_users; 33static struct miscdevice wm831x_wdt_miscdev; 34static int wm831x_wdt_expect_close; 35static DEFINE_MUTEX(wdt_mutex); 36static struct wm831x *wm831x; 37static unsigned int update_gpio; 38static unsigned int update_state; | 31struct wm831x_wdt_drvdata { 32 struct watchdog_device wdt; 33 struct wm831x *wm831x; 34 struct mutex lock; 35 int update_gpio; 36 int update_state; 37}; |
39 40/* We can't use the sub-second values here but they're included 41 * for completeness. */ 42static struct { | 38 39/* We can't use the sub-second values here but they're included 40 * for completeness. */ 41static struct { |
43 int time; /* Seconds */ 44 u16 val; /* WDOG_TO value */ | 42 unsigned int time; /* Seconds */ 43 u16 val; /* WDOG_TO value */ |
45} wm831x_wdt_cfgs[] = { 46 { 1, 2 }, 47 { 2, 3 }, 48 { 4, 4 }, 49 { 8, 5 }, 50 { 16, 6 }, 51 { 32, 7 }, 52 { 33, 7 }, /* Actually 32.768s so include both, others round down */ 53}; 54 | 44} wm831x_wdt_cfgs[] = { 45 { 1, 2 }, 46 { 2, 3 }, 47 { 4, 4 }, 48 { 8, 5 }, 49 { 16, 6 }, 50 { 32, 7 }, 51 { 33, 7 }, /* Actually 32.768s so include both, others round down */ 52}; 53 |
55static int wm831x_wdt_set_timeout(struct wm831x *wm831x, u16 value) | 54static int wm831x_wdt_start(struct watchdog_device *wdt_dev) |
56{ | 55{ |
56 struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev); 57 struct wm831x *wm831x = driver_data->wm831x; |
|
57 int ret; 58 | 58 int ret; 59 |
59 mutex_lock(&wdt_mutex); | 60 mutex_lock(&driver_data->lock); |
60 61 ret = wm831x_reg_unlock(wm831x); 62 if (ret == 0) { 63 ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG, | 61 62 ret = wm831x_reg_unlock(wm831x); 63 if (ret == 0) { 64 ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG, |
64 WM831X_WDOG_TO_MASK, value); 65 wm831x_reg_lock(wm831x); 66 } else { 67 dev_err(wm831x->dev, "Failed to unlock security key: %d\n", 68 ret); 69 } 70 71 mutex_unlock(&wdt_mutex); 72 73 return ret; 74} 75 76static int wm831x_wdt_start(struct wm831x *wm831x) 77{ 78 int ret; 79 80 mutex_lock(&wdt_mutex); 81 82 ret = wm831x_reg_unlock(wm831x); 83 if (ret == 0) { 84 ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG, | |
85 WM831X_WDOG_ENA, WM831X_WDOG_ENA); 86 wm831x_reg_lock(wm831x); 87 } else { 88 dev_err(wm831x->dev, "Failed to unlock security key: %d\n", 89 ret); 90 } 91 | 65 WM831X_WDOG_ENA, WM831X_WDOG_ENA); 66 wm831x_reg_lock(wm831x); 67 } else { 68 dev_err(wm831x->dev, "Failed to unlock security key: %d\n", 69 ret); 70 } 71 |
92 mutex_unlock(&wdt_mutex); | 72 mutex_unlock(&driver_data->lock); |
93 94 return ret; 95} 96 | 73 74 return ret; 75} 76 |
97static int wm831x_wdt_stop(struct wm831x *wm831x) | 77static int wm831x_wdt_stop(struct watchdog_device *wdt_dev) |
98{ | 78{ |
79 struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev); 80 struct wm831x *wm831x = driver_data->wm831x; |
|
99 int ret; 100 | 81 int ret; 82 |
101 mutex_lock(&wdt_mutex); | 83 mutex_lock(&driver_data->lock); |
102 103 ret = wm831x_reg_unlock(wm831x); 104 if (ret == 0) { 105 ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG, 106 WM831X_WDOG_ENA, 0); 107 wm831x_reg_lock(wm831x); 108 } else { 109 dev_err(wm831x->dev, "Failed to unlock security key: %d\n", 110 ret); 111 } 112 | 84 85 ret = wm831x_reg_unlock(wm831x); 86 if (ret == 0) { 87 ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG, 88 WM831X_WDOG_ENA, 0); 89 wm831x_reg_lock(wm831x); 90 } else { 91 dev_err(wm831x->dev, "Failed to unlock security key: %d\n", 92 ret); 93 } 94 |
113 mutex_unlock(&wdt_mutex); | 95 mutex_unlock(&driver_data->lock); |
114 115 return ret; 116} 117 | 96 97 return ret; 98} 99 |
118static int wm831x_wdt_kick(struct wm831x *wm831x) | 100static int wm831x_wdt_ping(struct watchdog_device *wdt_dev) |
119{ | 101{ |
102 struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev); 103 struct wm831x *wm831x = driver_data->wm831x; |
|
120 int ret; 121 u16 reg; 122 | 104 int ret; 105 u16 reg; 106 |
123 mutex_lock(&wdt_mutex); | 107 mutex_lock(&driver_data->lock); |
124 | 108 |
125 if (update_gpio) { 126 gpio_set_value_cansleep(update_gpio, update_state); 127 update_state = !update_state; | 109 if (driver_data->update_gpio) { 110 gpio_set_value_cansleep(driver_data->update_gpio, 111 driver_data->update_state); 112 driver_data->update_state = !driver_data->update_state; |
128 ret = 0; 129 goto out; 130 } 131 | 113 ret = 0; 114 goto out; 115 } 116 |
132 | |
133 reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG); 134 135 if (!(reg & WM831X_WDOG_RST_SRC)) { 136 dev_err(wm831x->dev, "Hardware watchdog update unsupported\n"); 137 ret = -EINVAL; 138 goto out; 139 } 140 --- 4 unchanged lines hidden (view full) --- 145 ret = wm831x_reg_write(wm831x, WM831X_WATCHDOG, reg); 146 wm831x_reg_lock(wm831x); 147 } else { 148 dev_err(wm831x->dev, "Failed to unlock security key: %d\n", 149 ret); 150 } 151 152out: | 117 reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG); 118 119 if (!(reg & WM831X_WDOG_RST_SRC)) { 120 dev_err(wm831x->dev, "Hardware watchdog update unsupported\n"); 121 ret = -EINVAL; 122 goto out; 123 } 124 --- 4 unchanged lines hidden (view full) --- 129 ret = wm831x_reg_write(wm831x, WM831X_WATCHDOG, reg); 130 wm831x_reg_lock(wm831x); 131 } else { 132 dev_err(wm831x->dev, "Failed to unlock security key: %d\n", 133 ret); 134 } 135 136out: |
153 mutex_unlock(&wdt_mutex); | 137 mutex_unlock(&driver_data->lock); |
154 155 return ret; 156} 157 | 138 139 return ret; 140} 141 |
158static int wm831x_wdt_open(struct inode *inode, struct file *file) | 142static int wm831x_wdt_set_timeout(struct watchdog_device *wdt_dev, 143 unsigned int timeout) |
159{ | 144{ |
160 int ret; | 145 struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev); 146 struct wm831x *wm831x = driver_data->wm831x; 147 int ret, i; |
161 | 148 |
162 if (!wm831x) 163 return -ENODEV; | 149 for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++) 150 if (wm831x_wdt_cfgs[i].time == timeout) 151 break; 152 if (i == ARRAY_SIZE(wm831x_wdt_cfgs)) 153 ret = -EINVAL; |
164 | 154 |
165 if (test_and_set_bit(0, &wm831x_wdt_users)) 166 return -EBUSY; 167 168 ret = wm831x_wdt_start(wm831x); 169 if (ret != 0) 170 return ret; 171 172 return nonseekable_open(inode, file); 173} 174 175static int wm831x_wdt_release(struct inode *inode, struct file *file) 176{ 177 if (wm831x_wdt_expect_close) 178 wm831x_wdt_stop(wm831x); 179 else { 180 dev_warn(wm831x->dev, "Watchdog device closed uncleanly\n"); 181 wm831x_wdt_kick(wm831x); | 155 ret = wm831x_reg_unlock(wm831x); 156 if (ret == 0) { 157 ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG, 158 WM831X_WDOG_TO_MASK, 159 wm831x_wdt_cfgs[i].val); 160 wm831x_reg_lock(wm831x); 161 } else { 162 dev_err(wm831x->dev, "Failed to unlock security key: %d\n", 163 ret); |
182 } 183 | 164 } 165 |
184 clear_bit(0, &wm831x_wdt_users); 185 186 return 0; | 166 return ret; |
187} 188 | 167} 168 |
189static ssize_t wm831x_wdt_write(struct file *file, 190 const char __user *data, size_t count, 191 loff_t *ppos) 192{ 193 size_t i; 194 195 if (count) { 196 wm831x_wdt_kick(wm831x); 197 198 if (!nowayout) { 199 /* In case it was set long ago */ 200 wm831x_wdt_expect_close = 0; 201 202 /* scan to see whether or not we got the magic 203 character */ 204 for (i = 0; i != count; i++) { 205 char c; 206 if (get_user(c, data + i)) 207 return -EFAULT; 208 if (c == 'V') 209 wm831x_wdt_expect_close = 42; 210 } 211 } 212 } 213 return count; 214} 215 216static const struct watchdog_info ident = { | 169static const struct watchdog_info wm831x_wdt_info = { |
217 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE, 218 .identity = "WM831x Watchdog", 219}; 220 | 170 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE, 171 .identity = "WM831x Watchdog", 172}; 173 |
221static long wm831x_wdt_ioctl(struct file *file, unsigned int cmd, 222 unsigned long arg) 223{ 224 int ret = -ENOTTY, time, i; 225 void __user *argp = (void __user *)arg; 226 int __user *p = argp; 227 u16 reg; 228 229 switch (cmd) { 230 case WDIOC_GETSUPPORT: 231 ret = copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0; 232 break; 233 234 case WDIOC_GETSTATUS: 235 case WDIOC_GETBOOTSTATUS: 236 ret = put_user(0, p); 237 break; 238 239 case WDIOC_SETOPTIONS: 240 { 241 int options; 242 243 if (get_user(options, p)) 244 return -EFAULT; 245 246 ret = -EINVAL; 247 248 /* Setting both simultaneously means at least one must fail */ 249 if (options == WDIOS_DISABLECARD) 250 ret = wm831x_wdt_start(wm831x); 251 252 if (options == WDIOS_ENABLECARD) 253 ret = wm831x_wdt_stop(wm831x); 254 break; 255 } 256 257 case WDIOC_KEEPALIVE: 258 ret = wm831x_wdt_kick(wm831x); 259 break; 260 261 case WDIOC_SETTIMEOUT: 262 ret = get_user(time, p); 263 if (ret) 264 break; 265 266 if (time == 0) { 267 if (nowayout) 268 ret = -EINVAL; 269 else 270 wm831x_wdt_stop(wm831x); 271 break; 272 } 273 274 for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++) 275 if (wm831x_wdt_cfgs[i].time == time) 276 break; 277 if (i == ARRAY_SIZE(wm831x_wdt_cfgs)) 278 ret = -EINVAL; 279 else 280 ret = wm831x_wdt_set_timeout(wm831x, 281 wm831x_wdt_cfgs[i].val); 282 break; 283 284 case WDIOC_GETTIMEOUT: 285 reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG); 286 reg &= WM831X_WDOG_TO_MASK; 287 for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++) 288 if (wm831x_wdt_cfgs[i].val == reg) 289 break; 290 if (i == ARRAY_SIZE(wm831x_wdt_cfgs)) { 291 dev_warn(wm831x->dev, 292 "Unknown watchdog configuration: %x\n", reg); 293 ret = -EINVAL; 294 } else 295 ret = put_user(wm831x_wdt_cfgs[i].time, p); 296 297 } 298 299 return ret; 300} 301 302static const struct file_operations wm831x_wdt_fops = { | 174static const struct watchdog_ops wm831x_wdt_ops = { |
303 .owner = THIS_MODULE, | 175 .owner = THIS_MODULE, |
304 .llseek = no_llseek, 305 .write = wm831x_wdt_write, 306 .unlocked_ioctl = wm831x_wdt_ioctl, 307 .open = wm831x_wdt_open, 308 .release = wm831x_wdt_release, | 176 .start = wm831x_wdt_start, 177 .stop = wm831x_wdt_stop, 178 .ping = wm831x_wdt_ping, 179 .set_timeout = wm831x_wdt_set_timeout, |
309}; 310 | 180}; 181 |
311static struct miscdevice wm831x_wdt_miscdev = { 312 .minor = WATCHDOG_MINOR, 313 .name = "watchdog", 314 .fops = &wm831x_wdt_fops, 315}; 316 | |
317static int __devinit wm831x_wdt_probe(struct platform_device *pdev) 318{ | 182static int __devinit wm831x_wdt_probe(struct platform_device *pdev) 183{ |
184 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); |
|
319 struct wm831x_pdata *chip_pdata; 320 struct wm831x_watchdog_pdata *pdata; | 185 struct wm831x_pdata *chip_pdata; 186 struct wm831x_watchdog_pdata *pdata; |
321 int reg, ret; | 187 struct wm831x_wdt_drvdata *driver_data; 188 struct watchdog_device *wm831x_wdt; 189 int reg, ret, i; |
322 | 190 |
323 if (wm831x) { 324 dev_err(&pdev->dev, "wm831x watchdog already registered\n"); 325 return -EBUSY; 326 } 327 328 wm831x = dev_get_drvdata(pdev->dev.parent); 329 | |
330 ret = wm831x_reg_read(wm831x, WM831X_WATCHDOG); 331 if (ret < 0) { 332 dev_err(wm831x->dev, "Failed to read watchdog status: %d\n", 333 ret); 334 goto err; 335 } 336 reg = ret; 337 338 if (reg & WM831X_WDOG_DEBUG) 339 dev_warn(wm831x->dev, "Watchdog is paused\n"); 340 | 191 ret = wm831x_reg_read(wm831x, WM831X_WATCHDOG); 192 if (ret < 0) { 193 dev_err(wm831x->dev, "Failed to read watchdog status: %d\n", 194 ret); 195 goto err; 196 } 197 reg = ret; 198 199 if (reg & WM831X_WDOG_DEBUG) 200 dev_warn(wm831x->dev, "Watchdog is paused\n"); 201 |
202 driver_data = kzalloc(sizeof(*driver_data), GFP_KERNEL); 203 if (!driver_data) { 204 dev_err(wm831x->dev, "Unable to alloacate watchdog device\n"); 205 ret = -ENOMEM; 206 goto err; 207 } 208 209 mutex_init(&driver_data->lock); 210 driver_data->wm831x = wm831x; 211 212 wm831x_wdt = &driver_data->wdt; 213 214 wm831x_wdt->info = &wm831x_wdt_info; 215 wm831x_wdt->ops = &wm831x_wdt_ops; 216 watchdog_set_drvdata(wm831x_wdt, driver_data); 217 218 if (nowayout) 219 wm831x_wdt->status |= WDOG_NO_WAY_OUT; 220 221 reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG); 222 reg &= WM831X_WDOG_TO_MASK; 223 for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++) 224 if (wm831x_wdt_cfgs[i].val == reg) 225 break; 226 if (i == ARRAY_SIZE(wm831x_wdt_cfgs)) 227 dev_warn(wm831x->dev, 228 "Unknown watchdog timeout: %x\n", reg); 229 else 230 wm831x_wdt->timeout = wm831x_wdt_cfgs[i].time; 231 |
|
341 /* Apply any configuration */ 342 if (pdev->dev.parent->platform_data) { 343 chip_pdata = pdev->dev.parent->platform_data; 344 pdata = chip_pdata->watchdog; 345 } else { 346 pdata = NULL; 347 } 348 --- 7 unchanged lines hidden (view full) --- 356 357 if (pdata->update_gpio) { 358 ret = gpio_request(pdata->update_gpio, 359 "Watchdog update"); 360 if (ret < 0) { 361 dev_err(wm831x->dev, 362 "Failed to request update GPIO: %d\n", 363 ret); | 232 /* Apply any configuration */ 233 if (pdev->dev.parent->platform_data) { 234 chip_pdata = pdev->dev.parent->platform_data; 235 pdata = chip_pdata->watchdog; 236 } else { 237 pdata = NULL; 238 } 239 --- 7 unchanged lines hidden (view full) --- 247 248 if (pdata->update_gpio) { 249 ret = gpio_request(pdata->update_gpio, 250 "Watchdog update"); 251 if (ret < 0) { 252 dev_err(wm831x->dev, 253 "Failed to request update GPIO: %d\n", 254 ret); |
364 goto err; | 255 goto err_alloc; |
365 } 366 367 ret = gpio_direction_output(pdata->update_gpio, 0); 368 if (ret != 0) { 369 dev_err(wm831x->dev, 370 "gpio_direction_output returned: %d\n", 371 ret); 372 goto err_gpio; 373 } 374 | 256 } 257 258 ret = gpio_direction_output(pdata->update_gpio, 0); 259 if (ret != 0) { 260 dev_err(wm831x->dev, 261 "gpio_direction_output returned: %d\n", 262 ret); 263 goto err_gpio; 264 } 265 |
375 update_gpio = pdata->update_gpio; | 266 driver_data->update_gpio = pdata->update_gpio; |
376 377 /* Make sure the watchdog takes hardware updates */ 378 reg |= WM831X_WDOG_RST_SRC; 379 } 380 381 ret = wm831x_reg_unlock(wm831x); 382 if (ret == 0) { 383 ret = wm831x_reg_write(wm831x, WM831X_WATCHDOG, reg); 384 wm831x_reg_lock(wm831x); 385 } else { 386 dev_err(wm831x->dev, 387 "Failed to unlock security key: %d\n", ret); 388 goto err_gpio; 389 } 390 } 391 | 267 268 /* Make sure the watchdog takes hardware updates */ 269 reg |= WM831X_WDOG_RST_SRC; 270 } 271 272 ret = wm831x_reg_unlock(wm831x); 273 if (ret == 0) { 274 ret = wm831x_reg_write(wm831x, WM831X_WATCHDOG, reg); 275 wm831x_reg_lock(wm831x); 276 } else { 277 dev_err(wm831x->dev, 278 "Failed to unlock security key: %d\n", ret); 279 goto err_gpio; 280 } 281 } 282 |
392 wm831x_wdt_miscdev.parent = &pdev->dev; 393 394 ret = misc_register(&wm831x_wdt_miscdev); | 283 ret = watchdog_register_device(&driver_data->wdt); |
395 if (ret != 0) { | 284 if (ret != 0) { |
396 dev_err(wm831x->dev, "Failed to register miscdev: %d\n", ret); | 285 dev_err(wm831x->dev, "watchdog_register_device() failed: %d\n", 286 ret); |
397 goto err_gpio; 398 } 399 | 287 goto err_gpio; 288 } 289 |
290 dev_set_drvdata(&pdev->dev, driver_data); 291 |
|
400 return 0; 401 402err_gpio: | 292 return 0; 293 294err_gpio: |
403 if (update_gpio) { 404 gpio_free(update_gpio); 405 update_gpio = 0; 406 } | 295 if (driver_data->update_gpio) 296 gpio_free(driver_data->update_gpio); 297err_alloc: 298 kfree(driver_data); |
407err: 408 return ret; 409} 410 411static int __devexit wm831x_wdt_remove(struct platform_device *pdev) 412{ | 299err: 300 return ret; 301} 302 303static int __devexit wm831x_wdt_remove(struct platform_device *pdev) 304{ |
413 if (update_gpio) { 414 gpio_free(update_gpio); 415 update_gpio = 0; 416 } | 305 struct wm831x_wdt_drvdata *driver_data = dev_get_drvdata(&pdev->dev); |
417 | 306 |
418 misc_deregister(&wm831x_wdt_miscdev); | 307 watchdog_unregister_device(&driver_data->wdt); |
419 | 308 |
309 if (driver_data->update_gpio) 310 gpio_free(driver_data->update_gpio); 311 |
|
420 return 0; 421} 422 423static struct platform_driver wm831x_wdt_driver = { 424 .probe = wm831x_wdt_probe, 425 .remove = __devexit_p(wm831x_wdt_remove), 426 .driver = { 427 .name = "wm831x-watchdog", --- 19 unchanged lines hidden --- | 312 return 0; 313} 314 315static struct platform_driver wm831x_wdt_driver = { 316 .probe = wm831x_wdt_probe, 317 .remove = __devexit_p(wm831x_wdt_remove), 318 .driver = { 319 .name = "wm831x-watchdog", --- 19 unchanged lines hidden --- |