Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 1 | /* |
Anton Vorontsov | 0d7b101 | 2008-07-03 23:51:36 -0700 | [diff] [blame] | 2 | * mpc8xxx_wdt.c - MPC8xx/MPC83xx/MPC86xx watchdog userspace interface |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 3 | * |
| 4 | * Authors: Dave Updegraff <dave@cray.org> |
Wim Van Sebroeck | 5f3b275 | 2011-02-23 20:04:38 +0000 | [diff] [blame] | 5 | * Kumar Gala <galak@kernel.crashing.org> |
| 6 | * Attribution: from 83xx_wst: Florian Schirmer <jolt@tuxbox.org> |
| 7 | * ..and from sc520_wdt |
Anton Vorontsov | 500c919 | 2008-07-03 23:51:34 -0700 | [diff] [blame] | 8 | * Copyright (c) 2008 MontaVista Software, Inc. |
| 9 | * Anton Vorontsov <avorontsov@ru.mvista.com> |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 10 | * |
| 11 | * Note: it appears that you can only actually ENABLE or DISABLE the thing |
| 12 | * once after POR. Once enabled, you cannot disable, and vice versa. |
| 13 | * |
| 14 | * This program is free software; you can redistribute it and/or modify it |
| 15 | * under the terms of the GNU General Public License as published by the |
| 16 | * Free Software Foundation; either version 2 of the License, or (at your |
| 17 | * option) any later version. |
| 18 | */ |
| 19 | |
Joe Perches | 27c766a | 2012-02-15 15:06:19 -0800 | [diff] [blame] | 20 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| 21 | |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 22 | #include <linux/fs.h> |
| 23 | #include <linux/init.h> |
| 24 | #include <linux/kernel.h> |
Anton Vorontsov | 500c919 | 2008-07-03 23:51:34 -0700 | [diff] [blame] | 25 | #include <linux/timer.h> |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 26 | #include <linux/miscdevice.h> |
Rob Herring | 5af5073 | 2013-09-17 14:28:33 -0500 | [diff] [blame] | 27 | #include <linux/of_address.h> |
Anton Vorontsov | ef8ab12 | 2008-07-03 23:51:32 -0700 | [diff] [blame] | 28 | #include <linux/of_platform.h> |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 29 | #include <linux/module.h> |
| 30 | #include <linux/watchdog.h> |
Alan Cox | f26ef3d | 2008-05-19 14:07:09 +0100 | [diff] [blame] | 31 | #include <linux/io.h> |
| 32 | #include <linux/uaccess.h> |
Anton Vorontsov | ef8ab12 | 2008-07-03 23:51:32 -0700 | [diff] [blame] | 33 | #include <sysdev/fsl_soc.h> |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 34 | |
Anton Vorontsov | 59ca1b0 | 2008-07-03 23:51:35 -0700 | [diff] [blame] | 35 | struct mpc8xxx_wdt { |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 36 | __be32 res0; |
| 37 | __be32 swcrr; /* System watchdog control register */ |
| 38 | #define SWCRR_SWTC 0xFFFF0000 /* Software Watchdog Time Count. */ |
| 39 | #define SWCRR_SWEN 0x00000004 /* Watchdog Enable bit. */ |
| 40 | #define SWCRR_SWRI 0x00000002 /* Software Watchdog Reset/Interrupt Select bit.*/ |
| 41 | #define SWCRR_SWPR 0x00000001 /* Software Watchdog Counter Prescale bit. */ |
| 42 | __be32 swcnr; /* System watchdog count register */ |
| 43 | u8 res1[2]; |
| 44 | __be16 swsrr; /* System watchdog service register */ |
| 45 | u8 res2[0xF0]; |
| 46 | }; |
| 47 | |
Anton Vorontsov | 59ca1b0 | 2008-07-03 23:51:35 -0700 | [diff] [blame] | 48 | struct mpc8xxx_wdt_type { |
Anton Vorontsov | 500c919 | 2008-07-03 23:51:34 -0700 | [diff] [blame] | 49 | int prescaler; |
| 50 | bool hw_enabled; |
| 51 | }; |
| 52 | |
Anton Vorontsov | 59ca1b0 | 2008-07-03 23:51:35 -0700 | [diff] [blame] | 53 | static struct mpc8xxx_wdt __iomem *wd_base; |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 54 | |
| 55 | static u16 timeout = 0xffff; |
| 56 | module_param(timeout, ushort, 0); |
Alan Cox | f26ef3d | 2008-05-19 14:07:09 +0100 | [diff] [blame] | 57 | MODULE_PARM_DESC(timeout, |
Randy Dunlap | 76550d3 | 2010-05-01 09:46:15 -0700 | [diff] [blame] | 58 | "Watchdog timeout in ticks. (0<timeout<65536, default=65535)"); |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 59 | |
Rusty Russell | 90ab5ee | 2012-01-13 09:32:20 +1030 | [diff] [blame] | 60 | static bool reset = 1; |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 61 | module_param(reset, bool, 0); |
Alan Cox | f26ef3d | 2008-05-19 14:07:09 +0100 | [diff] [blame] | 62 | MODULE_PARM_DESC(reset, |
| 63 | "Watchdog Interrupt/Reset Mode. 0 = interrupt, 1 = reset"); |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 64 | |
Wim Van Sebroeck | 86a1e18 | 2012-03-05 16:51:11 +0100 | [diff] [blame] | 65 | static bool nowayout = WATCHDOG_NOWAYOUT; |
| 66 | module_param(nowayout, bool, 0); |
Anton Vorontsov | 500c919 | 2008-07-03 23:51:34 -0700 | [diff] [blame] | 67 | MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started " |
| 68 | "(default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); |
| 69 | |
Alexey Dobriyan | c7dfd0c | 2007-11-01 16:27:08 -0700 | [diff] [blame] | 70 | static DEFINE_SPINLOCK(wdt_spinlock); |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 71 | |
Anton Vorontsov | 59ca1b0 | 2008-07-03 23:51:35 -0700 | [diff] [blame] | 72 | static void mpc8xxx_wdt_keepalive(void) |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 73 | { |
| 74 | /* Ping the WDT */ |
| 75 | spin_lock(&wdt_spinlock); |
| 76 | out_be16(&wd_base->swsrr, 0x556c); |
| 77 | out_be16(&wd_base->swsrr, 0xaa39); |
| 78 | spin_unlock(&wdt_spinlock); |
| 79 | } |
| 80 | |
Christophe Leroy | d5cfaf0 | 2013-12-04 07:32:14 +0100 | [diff] [blame] | 81 | static struct watchdog_device mpc8xxx_wdt_dev; |
Anton Vorontsov | 59ca1b0 | 2008-07-03 23:51:35 -0700 | [diff] [blame] | 82 | static void mpc8xxx_wdt_timer_ping(unsigned long arg); |
Christophe Leroy | d5cfaf0 | 2013-12-04 07:32:14 +0100 | [diff] [blame] | 83 | static DEFINE_TIMER(wdt_timer, mpc8xxx_wdt_timer_ping, 0, |
| 84 | (unsigned long)&mpc8xxx_wdt_dev); |
Anton Vorontsov | 500c919 | 2008-07-03 23:51:34 -0700 | [diff] [blame] | 85 | |
Anton Vorontsov | 59ca1b0 | 2008-07-03 23:51:35 -0700 | [diff] [blame] | 86 | static void mpc8xxx_wdt_timer_ping(unsigned long arg) |
Anton Vorontsov | 500c919 | 2008-07-03 23:51:34 -0700 | [diff] [blame] | 87 | { |
Christophe Leroy | d5cfaf0 | 2013-12-04 07:32:14 +0100 | [diff] [blame] | 88 | struct watchdog_device *w = (struct watchdog_device *)arg; |
| 89 | |
Anton Vorontsov | 59ca1b0 | 2008-07-03 23:51:35 -0700 | [diff] [blame] | 90 | mpc8xxx_wdt_keepalive(); |
Anton Vorontsov | 500c919 | 2008-07-03 23:51:34 -0700 | [diff] [blame] | 91 | /* We're pinging it twice faster than needed, just to be sure. */ |
Christophe Leroy | d5cfaf0 | 2013-12-04 07:32:14 +0100 | [diff] [blame] | 92 | mod_timer(&wdt_timer, jiffies + HZ * w->timeout / 2); |
Anton Vorontsov | 500c919 | 2008-07-03 23:51:34 -0700 | [diff] [blame] | 93 | } |
| 94 | |
Christophe Leroy | d5cfaf0 | 2013-12-04 07:32:14 +0100 | [diff] [blame] | 95 | static int mpc8xxx_wdt_start(struct watchdog_device *w) |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 96 | { |
Uwe Kleine-König | a57e06f | 2015-08-12 10:15:52 +0200 | [diff] [blame] | 97 | u32 tmp = SWCRR_SWEN | SWCRR_SWPR; |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 98 | |
| 99 | /* Good, fire up the show */ |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 100 | if (reset) |
| 101 | tmp |= SWCRR_SWRI; |
| 102 | |
| 103 | tmp |= timeout << 16; |
| 104 | |
| 105 | out_be32(&wd_base->swcrr, tmp); |
| 106 | |
Anton Vorontsov | 500c919 | 2008-07-03 23:51:34 -0700 | [diff] [blame] | 107 | del_timer_sync(&wdt_timer); |
| 108 | |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 109 | return 0; |
| 110 | } |
| 111 | |
Christophe Leroy | d5cfaf0 | 2013-12-04 07:32:14 +0100 | [diff] [blame] | 112 | static int mpc8xxx_wdt_ping(struct watchdog_device *w) |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 113 | { |
Christophe Leroy | d5cfaf0 | 2013-12-04 07:32:14 +0100 | [diff] [blame] | 114 | mpc8xxx_wdt_keepalive(); |
| 115 | return 0; |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 116 | } |
| 117 | |
Christophe Leroy | d5cfaf0 | 2013-12-04 07:32:14 +0100 | [diff] [blame] | 118 | static int mpc8xxx_wdt_stop(struct watchdog_device *w) |
| 119 | { |
| 120 | mod_timer(&wdt_timer, jiffies); |
| 121 | return 0; |
| 122 | } |
| 123 | |
| 124 | static struct watchdog_info mpc8xxx_wdt_info = { |
| 125 | .options = WDIOF_KEEPALIVEPING, |
| 126 | .firmware_version = 1, |
| 127 | .identity = "MPC8xxx", |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 128 | }; |
| 129 | |
Christophe Leroy | d5cfaf0 | 2013-12-04 07:32:14 +0100 | [diff] [blame] | 130 | static struct watchdog_ops mpc8xxx_wdt_ops = { |
| 131 | .owner = THIS_MODULE, |
| 132 | .start = mpc8xxx_wdt_start, |
| 133 | .ping = mpc8xxx_wdt_ping, |
| 134 | .stop = mpc8xxx_wdt_stop, |
| 135 | }; |
| 136 | |
| 137 | static struct watchdog_device mpc8xxx_wdt_dev = { |
| 138 | .info = &mpc8xxx_wdt_info, |
| 139 | .ops = &mpc8xxx_wdt_ops, |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 140 | }; |
| 141 | |
Bill Pemberton | 2d991a1 | 2012-11-19 13:21:41 -0500 | [diff] [blame] | 142 | static int mpc8xxx_wdt_probe(struct platform_device *ofdev) |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 143 | { |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 144 | int ret; |
Grant Likely | b1608d6 | 2011-05-18 11:19:24 -0600 | [diff] [blame] | 145 | const struct of_device_id *match; |
Michael Guntsche | de2b606 | 2010-06-02 02:25:52 -0600 | [diff] [blame] | 146 | struct device_node *np = ofdev->dev.of_node; |
Arnd Bergmann | 639397e | 2012-05-21 21:57:39 +0200 | [diff] [blame] | 147 | const struct mpc8xxx_wdt_type *wdt_type; |
Anton Vorontsov | ef8ab12 | 2008-07-03 23:51:32 -0700 | [diff] [blame] | 148 | u32 freq = fsl_get_sys_freq(); |
Anton Vorontsov | 500c919 | 2008-07-03 23:51:34 -0700 | [diff] [blame] | 149 | bool enabled; |
Christophe Leroy | d5cfaf0 | 2013-12-04 07:32:14 +0100 | [diff] [blame] | 150 | unsigned int timeout_sec; |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 151 | |
Uwe Kleine-König | f0ded83 | 2015-08-12 10:15:54 +0200 | [diff] [blame^] | 152 | wdt_type = of_device_get_match_data(&ofdev->dev); |
| 153 | if (!wdt_type) |
Grant Likely | 1c48a5c | 2011-02-17 02:43:24 -0700 | [diff] [blame] | 154 | return -EINVAL; |
Grant Likely | 1c48a5c | 2011-02-17 02:43:24 -0700 | [diff] [blame] | 155 | |
Anton Vorontsov | ef8ab12 | 2008-07-03 23:51:32 -0700 | [diff] [blame] | 156 | if (!freq || freq == -1) |
| 157 | return -EINVAL; |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 158 | |
Anton Vorontsov | 500c919 | 2008-07-03 23:51:34 -0700 | [diff] [blame] | 159 | wd_base = of_iomap(np, 0); |
Anton Vorontsov | ef8ab12 | 2008-07-03 23:51:32 -0700 | [diff] [blame] | 160 | if (!wd_base) |
| 161 | return -ENOMEM; |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 162 | |
Anton Vorontsov | 500c919 | 2008-07-03 23:51:34 -0700 | [diff] [blame] | 163 | enabled = in_be32(&wd_base->swcrr) & SWCRR_SWEN; |
| 164 | if (!enabled && wdt_type->hw_enabled) { |
Joe Perches | 27c766a | 2012-02-15 15:06:19 -0800 | [diff] [blame] | 165 | pr_info("could not be enabled in software\n"); |
Anton Vorontsov | 500c919 | 2008-07-03 23:51:34 -0700 | [diff] [blame] | 166 | ret = -ENOSYS; |
| 167 | goto err_unmap; |
| 168 | } |
| 169 | |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 170 | /* Calculate the timeout in seconds */ |
Uwe Kleine-König | a57e06f | 2015-08-12 10:15:52 +0200 | [diff] [blame] | 171 | timeout_sec = (timeout * wdt_type->prescaler) / freq; |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 172 | |
Christophe Leroy | d5cfaf0 | 2013-12-04 07:32:14 +0100 | [diff] [blame] | 173 | mpc8xxx_wdt_dev.timeout = timeout_sec; |
Uwe Kleine-König | 50ffb53 | 2015-08-12 10:15:53 +0200 | [diff] [blame] | 174 | |
| 175 | watchdog_set_nowayout(&mpc8xxx_wdt_dev, nowayout); |
| 176 | |
| 177 | ret = watchdog_register_device(&mpc8xxx_wdt_dev); |
| 178 | if (ret) { |
| 179 | pr_err("cannot register watchdog device (err=%d)\n", ret); |
Anton Vorontsov | 593fc17 | 2008-08-20 16:38:36 -0700 | [diff] [blame] | 180 | goto err_unmap; |
Uwe Kleine-König | 50ffb53 | 2015-08-12 10:15:53 +0200 | [diff] [blame] | 181 | } |
Anton Vorontsov | 593fc17 | 2008-08-20 16:38:36 -0700 | [diff] [blame] | 182 | |
Joe Perches | 27c766a | 2012-02-15 15:06:19 -0800 | [diff] [blame] | 183 | pr_info("WDT driver for MPC8xxx initialized. mode:%s timeout=%d (%d seconds)\n", |
| 184 | reset ? "reset" : "interrupt", timeout, timeout_sec); |
Anton Vorontsov | 500c919 | 2008-07-03 23:51:34 -0700 | [diff] [blame] | 185 | |
| 186 | /* |
| 187 | * If the watchdog was previously enabled or we're running on |
Anton Vorontsov | 59ca1b0 | 2008-07-03 23:51:35 -0700 | [diff] [blame] | 188 | * MPC8xxx, we should ping the wdt from the kernel until the |
Anton Vorontsov | 500c919 | 2008-07-03 23:51:34 -0700 | [diff] [blame] | 189 | * userspace handles it. |
| 190 | */ |
| 191 | if (enabled) |
Christophe Leroy | d5cfaf0 | 2013-12-04 07:32:14 +0100 | [diff] [blame] | 192 | mod_timer(&wdt_timer, jiffies); |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 193 | return 0; |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 194 | err_unmap: |
| 195 | iounmap(wd_base); |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 196 | return ret; |
| 197 | } |
| 198 | |
Bill Pemberton | 4b12b89 | 2012-11-19 13:26:24 -0500 | [diff] [blame] | 199 | static int mpc8xxx_wdt_remove(struct platform_device *ofdev) |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 200 | { |
Christophe Leroy | d5cfaf0 | 2013-12-04 07:32:14 +0100 | [diff] [blame] | 201 | pr_crit("Watchdog removed, expect the %s soon!\n", |
| 202 | reset ? "reset" : "machine check exception"); |
Anton Vorontsov | 500c919 | 2008-07-03 23:51:34 -0700 | [diff] [blame] | 203 | del_timer_sync(&wdt_timer); |
Christophe Leroy | d5cfaf0 | 2013-12-04 07:32:14 +0100 | [diff] [blame] | 204 | watchdog_unregister_device(&mpc8xxx_wdt_dev); |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 205 | iounmap(wd_base); |
| 206 | |
| 207 | return 0; |
| 208 | } |
| 209 | |
Anton Vorontsov | 59ca1b0 | 2008-07-03 23:51:35 -0700 | [diff] [blame] | 210 | static const struct of_device_id mpc8xxx_wdt_match[] = { |
Anton Vorontsov | ef8ab12 | 2008-07-03 23:51:32 -0700 | [diff] [blame] | 211 | { |
| 212 | .compatible = "mpc83xx_wdt", |
Anton Vorontsov | 59ca1b0 | 2008-07-03 23:51:35 -0700 | [diff] [blame] | 213 | .data = &(struct mpc8xxx_wdt_type) { |
Anton Vorontsov | 500c919 | 2008-07-03 23:51:34 -0700 | [diff] [blame] | 214 | .prescaler = 0x10000, |
| 215 | }, |
| 216 | }, |
| 217 | { |
| 218 | .compatible = "fsl,mpc8610-wdt", |
Anton Vorontsov | 59ca1b0 | 2008-07-03 23:51:35 -0700 | [diff] [blame] | 219 | .data = &(struct mpc8xxx_wdt_type) { |
Anton Vorontsov | 500c919 | 2008-07-03 23:51:34 -0700 | [diff] [blame] | 220 | .prescaler = 0x10000, |
| 221 | .hw_enabled = true, |
| 222 | }, |
Anton Vorontsov | ef8ab12 | 2008-07-03 23:51:32 -0700 | [diff] [blame] | 223 | }, |
Anton Vorontsov | 0d7b101 | 2008-07-03 23:51:36 -0700 | [diff] [blame] | 224 | { |
| 225 | .compatible = "fsl,mpc823-wdt", |
| 226 | .data = &(struct mpc8xxx_wdt_type) { |
| 227 | .prescaler = 0x800, |
Christophe Leroy | 4af897f | 2013-11-30 16:45:40 +0100 | [diff] [blame] | 228 | .hw_enabled = true, |
Anton Vorontsov | 0d7b101 | 2008-07-03 23:51:36 -0700 | [diff] [blame] | 229 | }, |
| 230 | }, |
Anton Vorontsov | ef8ab12 | 2008-07-03 23:51:32 -0700 | [diff] [blame] | 231 | {}, |
| 232 | }; |
Anton Vorontsov | 59ca1b0 | 2008-07-03 23:51:35 -0700 | [diff] [blame] | 233 | MODULE_DEVICE_TABLE(of, mpc8xxx_wdt_match); |
Anton Vorontsov | ef8ab12 | 2008-07-03 23:51:32 -0700 | [diff] [blame] | 234 | |
Grant Likely | 1c48a5c | 2011-02-17 02:43:24 -0700 | [diff] [blame] | 235 | static struct platform_driver mpc8xxx_wdt_driver = { |
Anton Vorontsov | 59ca1b0 | 2008-07-03 23:51:35 -0700 | [diff] [blame] | 236 | .probe = mpc8xxx_wdt_probe, |
Bill Pemberton | 8226871 | 2012-11-19 13:21:12 -0500 | [diff] [blame] | 237 | .remove = mpc8xxx_wdt_remove, |
Grant Likely | 4018294 | 2010-04-13 16:13:02 -0700 | [diff] [blame] | 238 | .driver = { |
| 239 | .name = "mpc8xxx_wdt", |
Grant Likely | 4018294 | 2010-04-13 16:13:02 -0700 | [diff] [blame] | 240 | .of_match_table = mpc8xxx_wdt_match, |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 241 | }, |
| 242 | }; |
| 243 | |
Anton Vorontsov | 59ca1b0 | 2008-07-03 23:51:35 -0700 | [diff] [blame] | 244 | static int __init mpc8xxx_wdt_init(void) |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 245 | { |
Grant Likely | 1c48a5c | 2011-02-17 02:43:24 -0700 | [diff] [blame] | 246 | return platform_driver_register(&mpc8xxx_wdt_driver); |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 247 | } |
Anton Vorontsov | 0d7b101 | 2008-07-03 23:51:36 -0700 | [diff] [blame] | 248 | arch_initcall(mpc8xxx_wdt_init); |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 249 | |
Anton Vorontsov | 59ca1b0 | 2008-07-03 23:51:35 -0700 | [diff] [blame] | 250 | static void __exit mpc8xxx_wdt_exit(void) |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 251 | { |
Grant Likely | 1c48a5c | 2011-02-17 02:43:24 -0700 | [diff] [blame] | 252 | platform_driver_unregister(&mpc8xxx_wdt_driver); |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 253 | } |
Anton Vorontsov | 59ca1b0 | 2008-07-03 23:51:35 -0700 | [diff] [blame] | 254 | module_exit(mpc8xxx_wdt_exit); |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 255 | |
| 256 | MODULE_AUTHOR("Dave Updegraff, Kumar Gala"); |
Anton Vorontsov | 0d7b101 | 2008-07-03 23:51:36 -0700 | [diff] [blame] | 257 | MODULE_DESCRIPTION("Driver for watchdog timer in MPC8xx/MPC83xx/MPC86xx " |
| 258 | "uProcessors"); |
Kumar Gala | fabbfb9 | 2006-01-14 13:20:50 -0800 | [diff] [blame] | 259 | MODULE_LICENSE("GPL"); |