Merge branch 'master' into for-next

Fast-forwarded to current state of Linus' tree as there are patches to be
applied for files that didn't exist on the old branch.

18 files changed, 80 insertions, 68 deletions

diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index b69d71482554..1b0f98bc51b5 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -933,7 +933,7 @@ config PNX833X_WDT
         depends on SOC_PNX8335
         help
           Hardware driver for the PNX833x's watchdog. This is a
-          watchdog timer that will reboot the machine after a programable
+          watchdog timer that will reboot the machine after a programmable
           timer has expired and no process has written to /dev/watchdog during
           that time.
 
diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
index d520bf9c3355..3f8608b922a7 100644
--- a/drivers/watchdog/Makefile
+++ b/drivers/watchdog/Makefile
@@ -4,7 +4,7 @@
 
 # Only one watchdog can succeed. We probe the ISA/PCI/USB based
 # watchdog-cards first, then the architecture specific watchdog
-# drivers and then the architecture independant "softdog" driver.
+# drivers and then the architecture independent "softdog" driver.
 # This means that if your ISA/PCI/USB card isn't detected that
 # you can fall back to an architecture specific driver and if
 # that also fails then you can fall back to the software watchdog
@@ -153,7 +153,7 @@ obj-$(CONFIG_WATCHDOG_CP1XXX)		+= cpwd.o
 # Xen
 obj-$(CONFIG_XEN_WDT) += xen_wdt.o
 
-# Architecture Independant
+# Architecture Independent
 obj-$(CONFIG_WM831X_WATCHDOG) += wm831x_wdt.o
 obj-$(CONFIG_WM8350_WATCHDOG) += wm8350_wdt.o
 obj-$(CONFIG_MAX63XX_WATCHDOG) += max63xx_wdt.o
diff --git a/drivers/watchdog/acquirewdt.c b/drivers/watchdog/acquirewdt.c
index 2ffce4d75443..b6a2b58cbe64 100644
--- a/drivers/watchdog/acquirewdt.c
+++ b/drivers/watchdog/acquirewdt.c
@@ -26,7 +26,7 @@
  *      Theory of Operation:
  *              The Watch-Dog Timer is provided to ensure that standalone
  *              Systems can always recover from catastrophic conditions that
- *              caused the CPU to crash. This condition may have occured by
+ *              caused the CPU to crash. This condition may have occurred by
  *              external EMI or a software bug. When the CPU stops working
  *              correctly, hardware on the board will either perform a hardware
  *              reset (cold boot) or a non-maskable interrupt (NMI) to bring the
diff --git a/drivers/watchdog/davinci_wdt.c b/drivers/watchdog/davinci_wdt.c
index 596ba604e78d..51b5551b4e3f 100644
--- a/drivers/watchdog/davinci_wdt.c
+++ b/drivers/watchdog/davinci_wdt.c
@@ -202,7 +202,6 @@ static struct miscdevice davinci_wdt_miscdev = {
 static int __devinit davinci_wdt_probe(struct platform_device *pdev)
 {
         int ret = 0, size;
-        struct resource *res;
         struct device *dev = &pdev->dev;
 
         wdt_clk = clk_get(dev, NULL);
@@ -216,31 +215,31 @@ static int __devinit davinci_wdt_probe(struct platform_device *pdev)
 
         dev_info(dev, "heartbeat %d sec\n", heartbeat);
 
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (res == NULL) {
+        wdt_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (wdt_mem == NULL) {
                 dev_err(dev, "failed to get memory region resource\n");
                 return -ENOENT;
         }
 
-        size = resource_size(res);
-        wdt_mem = request_mem_region(res->start, size, pdev->name);
-
-        if (wdt_mem == NULL) {
+        size = resource_size(wdt_mem);
+        if (!request_mem_region(wdt_mem->start, size, pdev->name)) {
                 dev_err(dev, "failed to get memory region\n");
                 return -ENOENT;
         }
 
-        wdt_base = ioremap(res->start, size);
+        wdt_base = ioremap(wdt_mem->start, size);
         if (!wdt_base) {
                 dev_err(dev, "failed to map memory region\n");
+                release_mem_region(wdt_mem->start, size);
+                wdt_mem = NULL;
                 return -ENOMEM;
         }
 
         ret = misc_register(&davinci_wdt_miscdev);
         if (ret < 0) {
                 dev_err(dev, "cannot register misc device\n");
-                release_resource(wdt_mem);
-                kfree(wdt_mem);
+                release_mem_region(wdt_mem->start, size);
+                wdt_mem = NULL;
         } else {
                 set_bit(WDT_DEVICE_INITED, &wdt_status);
         }
@@ -253,8 +252,7 @@ static int __devexit davinci_wdt_remove(struct platform_device *pdev)
 {
         misc_deregister(&davinci_wdt_miscdev);
         if (wdt_mem) {
-                release_resource(wdt_mem);
-                kfree(wdt_mem);
+                release_mem_region(wdt_mem->start, resource_size(wdt_mem));
                 wdt_mem = NULL;
         }
 
diff --git a/drivers/watchdog/max63xx_wdt.c b/drivers/watchdog/max63xx_wdt.c
index 7a82ce5a6337..73ba2fd8e591 100644
--- a/drivers/watchdog/max63xx_wdt.c
+++ b/drivers/watchdog/max63xx_wdt.c
@@ -270,7 +270,6 @@ static int __devinit max63xx_wdt_probe(struct platform_device *pdev)
 {
         int ret = 0;
         int size;
-        struct resource *res;
         struct device *dev = &pdev->dev;
         struct max63xx_timeout *table;
 
@@ -294,21 +293,19 @@ static int __devinit max63xx_wdt_probe(struct platform_device *pdev)
 
         max63xx_pdev = pdev;
 
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (res == NULL) {
+        wdt_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (wdt_mem == NULL) {
                 dev_err(dev, "failed to get memory region resource\n");
                 return -ENOENT;
         }
 
-        size = resource_size(res);
-        wdt_mem = request_mem_region(res->start, size, pdev->name);
-
-        if (wdt_mem == NULL) {
+        size = resource_size(wdt_mem);
+        if (!request_mem_region(wdt_mem->start, size, pdev->name)) {
                 dev_err(dev, "failed to get memory region\n");
                 return -ENOENT;
         }
 
-        wdt_base = ioremap(res->start, size);
+        wdt_base = ioremap(wdt_mem->start, size);
         if (!wdt_base) {
                 dev_err(dev, "failed to map memory region\n");
                 ret = -ENOMEM;
@@ -326,8 +323,8 @@ static int __devinit max63xx_wdt_probe(struct platform_device *pdev)
 out_unmap:
         iounmap(wdt_base);
 out_request:
-        release_resource(wdt_mem);
-        kfree(wdt_mem);
+        release_mem_region(wdt_mem->start, size);
+        wdt_mem = NULL;
 
         return ret;
 }
@@ -336,8 +333,7 @@ static int __devexit max63xx_wdt_remove(struct platform_device *pdev)
 {
         misc_deregister(&max63xx_wdt_miscdev);
         if (wdt_mem) {
-                release_resource(wdt_mem);
-                kfree(wdt_mem);
+                release_mem_region(wdt_mem->start, resource_size(wdt_mem));
                 wdt_mem = NULL;
         }
 
diff --git a/drivers/watchdog/mpc8xxx_wdt.c b/drivers/watchdog/mpc8xxx_wdt.c
index 6709d723e017..528bceb220fd 100644
--- a/drivers/watchdog/mpc8xxx_wdt.c
+++ b/drivers/watchdog/mpc8xxx_wdt.c
@@ -195,7 +195,7 @@ static int __devinit mpc8xxx_wdt_probe(struct platform_device *ofdev)
 
         if (!ofdev->dev.of_match)
                 return -EINVAL;
-        wdt_type = match->data;
+        wdt_type = ofdev->dev.of_match->data;
 
         if (!freq || freq == -1)
                 return -EINVAL;
diff --git a/drivers/watchdog/nv_tco.c b/drivers/watchdog/nv_tco.c
index 267377a5a83e..afa78a54711e 100644
--- a/drivers/watchdog/nv_tco.c
+++ b/drivers/watchdog/nv_tco.c
@@ -302,7 +302,7 @@ MODULE_DEVICE_TABLE(pci, tco_pci_tbl);
  *      Init & exit routines
  */
 
-static unsigned char __init nv_tco_getdevice(void)
+static unsigned char __devinit nv_tco_getdevice(void)
 {
         struct pci_dev *dev = NULL;
         u32 val;
diff --git a/drivers/watchdog/pc87413_wdt.c b/drivers/watchdog/pc87413_wdt.c
index 139d773300c6..b7c139051575 100644
--- a/drivers/watchdog/pc87413_wdt.c
+++ b/drivers/watchdog/pc87413_wdt.c
@@ -49,7 +49,7 @@
 #define WDT_DATA_IO_PORT    (WDT_INDEX_IO_PORT+1)
 #define SWC_LDN             0x04
 #define SIOCFG2             0x22        /* Serial IO register */
-#define WDCTL               0x10        /* Watchdog-Timer-Controll-Register */
+#define WDCTL               0x10        /* Watchdog-Timer-Control-Register */
 #define WDTO                0x11        /* Watchdog timeout register */
 #define WDCFG               0x12        /* Watchdog config register */
 
diff --git a/drivers/watchdog/pnx4008_wdt.c b/drivers/watchdog/pnx4008_wdt.c
index c7cf4cbf8ab3..614933225560 100644
--- a/drivers/watchdog/pnx4008_wdt.c
+++ b/drivers/watchdog/pnx4008_wdt.c
@@ -254,7 +254,6 @@ static struct miscdevice pnx4008_wdt_miscdev = {
 static int __devinit pnx4008_wdt_probe(struct platform_device *pdev)
 {
         int ret = 0, size;
-        struct resource *res;
 
         if (heartbeat < 1 || heartbeat > MAX_HEARTBEAT)
                 heartbeat = DEFAULT_HEARTBEAT;
@@ -262,42 +261,42 @@ static int __devinit pnx4008_wdt_probe(struct platform_device *pdev)
         printk(KERN_INFO MODULE_NAME
                 "PNX4008 Watchdog Timer: heartbeat %d sec\n", heartbeat);
 
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (res == NULL) {
+        wdt_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (wdt_mem == NULL) {
                 printk(KERN_INFO MODULE_NAME
                         "failed to get memory region resouce\n");
                 return -ENOENT;
         }
 
-        size = resource_size(res);
-        wdt_mem = request_mem_region(res->start, size, pdev->name);
+        size = resource_size(wdt_mem);
 
-        if (wdt_mem == NULL) {
+        if (!request_mem_region(wdt_mem->start, size, pdev->name)) {
                 printk(KERN_INFO MODULE_NAME "failed to get memory region\n");
                 return -ENOENT;
         }
-        wdt_base = (void __iomem *)IO_ADDRESS(res->start);
+        wdt_base = (void __iomem *)IO_ADDRESS(wdt_mem->start);
 
         wdt_clk = clk_get(&pdev->dev, NULL);
         if (IS_ERR(wdt_clk)) {
                 ret = PTR_ERR(wdt_clk);
-                release_resource(wdt_mem);
-                kfree(wdt_mem);
+                release_mem_region(wdt_mem->start, size);
+                wdt_mem = NULL;
                 goto out;
         }
 
         ret = clk_enable(wdt_clk);
         if (ret) {
-                release_resource(wdt_mem);
-                kfree(wdt_mem);
+                release_mem_region(wdt_mem->start, size);
+                wdt_mem = NULL;
+                clk_put(wdt_clk);
                 goto out;
         }
 
         ret = misc_register(&pnx4008_wdt_miscdev);
         if (ret < 0) {
                 printk(KERN_ERR MODULE_NAME "cannot register misc device\n");
-                release_resource(wdt_mem);
-                kfree(wdt_mem);
+                release_mem_region(wdt_mem->start, size);
+                wdt_mem = NULL;
                 clk_disable(wdt_clk);
                 clk_put(wdt_clk);
         } else {
@@ -320,8 +319,7 @@ static int __devexit pnx4008_wdt_remove(struct platform_device *pdev)
         clk_put(wdt_clk);
 
         if (wdt_mem) {
-                release_resource(wdt_mem);
-                kfree(wdt_mem);
+                release_mem_region(wdt_mem->start, resource_size(wdt_mem));
                 wdt_mem = NULL;
         }
         return 0;
diff --git a/drivers/watchdog/rdc321x_wdt.c b/drivers/watchdog/rdc321x_wdt.c
index 3939e53f5f98..d8e725082fdc 100644
--- a/drivers/watchdog/rdc321x_wdt.c
+++ b/drivers/watchdog/rdc321x_wdt.c
@@ -37,6 +37,7 @@
 #include <linux/io.h>
 #include <linux/uaccess.h>
 #include <linux/mfd/rdc321x.h>
+#include <linux/mfd/core.h>
 
 #define RDC_WDT_MASK    0x80000000 /* Mask */
 #define RDC_WDT_EN      0x00800000 /* Enable bit */
@@ -231,7 +232,7 @@ static int __devinit rdc321x_wdt_probe(struct platform_device *pdev)
         struct resource *r;
         struct rdc321x_wdt_pdata *pdata;
 
-        pdata = platform_get_drvdata(pdev);
+        pdata = mfd_get_data(pdev);
         if (!pdata) {
                 dev_err(&pdev->dev, "no platform data supplied\n");
                 return -ENODEV;
diff --git a/drivers/watchdog/s3c2410_wdt.c b/drivers/watchdog/s3c2410_wdt.c
index 25b39bf35925..f7f5aa00df60 100644
--- a/drivers/watchdog/s3c2410_wdt.c
+++ b/drivers/watchdog/s3c2410_wdt.c
@@ -402,7 +402,6 @@ static inline void s3c2410wdt_cpufreq_deregister(void)
 
 static int __devinit s3c2410wdt_probe(struct platform_device *pdev)
 {
-        struct resource *res;
         struct device *dev;
         unsigned int wtcon;
         int started = 0;
@@ -416,20 +415,19 @@ static int __devinit s3c2410wdt_probe(struct platform_device *pdev)
 
         /* get the memory region for the watchdog timer */
 
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (res == NULL) {
+        wdt_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (wdt_mem == NULL) {
                 dev_err(dev, "no memory resource specified\n");
                 return -ENOENT;
         }
 
-        size = resource_size(res);
-        wdt_mem = request_mem_region(res->start, size, pdev->name);
-        if (wdt_mem == NULL) {
+        size = resource_size(wdt_mem);
+        if (!request_mem_region(wdt_mem->start, size, pdev->name)) {
                 dev_err(dev, "failed to get memory region\n");
                 return -EBUSY;
         }
 
-        wdt_base = ioremap(res->start, size);
+        wdt_base = ioremap(wdt_mem->start, size);
         if (wdt_base == NULL) {
                 dev_err(dev, "failed to ioremap() region\n");
                 ret = -EINVAL;
@@ -524,8 +522,8 @@ static int __devinit s3c2410wdt_probe(struct platform_device *pdev)
         iounmap(wdt_base);
 
  err_req:
-        release_resource(wdt_mem);
-        kfree(wdt_mem);
+        release_mem_region(wdt_mem->start, size);
+        wdt_mem = NULL;
 
         return ret;
 }
@@ -545,8 +543,7 @@ static int __devexit s3c2410wdt_remove(struct platform_device *dev)
 
         iounmap(wdt_base);
 
-        release_resource(wdt_mem);
-        kfree(wdt_mem);
+        release_mem_region(wdt_mem->start, resource_size(wdt_mem));
         wdt_mem = NULL;
         return 0;
 }
diff --git a/drivers/watchdog/sbc7240_wdt.c b/drivers/watchdog/sbc7240_wdt.c
index 67ddeb1c830a..ff11504c376e 100644
--- a/drivers/watchdog/sbc7240_wdt.c
+++ b/drivers/watchdog/sbc7240_wdt.c
@@ -273,7 +273,7 @@ static int __init sbc7240_wdt_init(void)
 
         /* The IO port 0x043 used to disable the watchdog
          * is already claimed by the system timer, so we
-         * cant request_region() it ...*/
+         * can't request_region() it ...*/
 
         if (timeout < 1 || timeout > SBC7240_MAX_TIMEOUT) {
                 timeout = SBC7240_TIMEOUT;
diff --git a/drivers/watchdog/sch311x_wdt.c b/drivers/watchdog/sch311x_wdt.c
index b61ab1c54293..c7cf4b01f58d 100644
--- a/drivers/watchdog/sch311x_wdt.c
+++ b/drivers/watchdog/sch311x_wdt.c
@@ -201,7 +201,7 @@ static void sch311x_wdt_get_status(int *status)
         spin_lock(&sch311x_wdt_data.io_lock);
 
         /* -- Watchdog timer control --
-         * Bit 0   Status Bit: 0 = Timer counting, 1 = Timeout occured
+         * Bit 0   Status Bit: 0 = Timer counting, 1 = Timeout occurred
          * Bit 1   Reserved
          * Bit 2   Force Timeout: 1 = Forces WD timeout event (self-cleaning)
          * Bit 3   P20 Force Timeout enabled:
diff --git a/drivers/watchdog/shwdt.c b/drivers/watchdog/shwdt.c
index 4e3e7eb5919c..db84f2322d1a 100644
--- a/drivers/watchdog/shwdt.c
+++ b/drivers/watchdog/shwdt.c
@@ -50,7 +50,7 @@
  * necssary.
  *
  * As a result of this timing problem, the only modes that are particularly
- * feasible are the 4096 and the 2048 divisors, which yeild 5.25 and 2.62ms
+ * feasible are the 4096 and the 2048 divisors, which yield 5.25 and 2.62ms
  * overflow periods respectively.
  *
  * Also, since we can't really expect userspace to be responsive enough
diff --git a/drivers/watchdog/smsc37b787_wdt.c b/drivers/watchdog/smsc37b787_wdt.c
index df88cfa05f35..e97b0499bd0d 100644
--- a/drivers/watchdog/smsc37b787_wdt.c
+++ b/drivers/watchdog/smsc37b787_wdt.c
@@ -191,7 +191,7 @@ static inline void wdt_timer_conf(unsigned char conf)
 static inline void wdt_timer_ctrl(unsigned char reg)
 {
         /* -- Watchdog timer control --
-         * Bit 0   Status Bit: 0 = Timer counting, 1 = Timeout occured
+         * Bit 0   Status Bit: 0 = Timer counting, 1 = Timeout occurred
          * Bit 1   Power LED Toggle: 0 = Disable Toggle, 1 = Toggle at 1 Hz
          * Bit 2   Force Timeout: 1 = Forces WD timeout event (self-cleaning)
          * Bit 3   P20 Force Timeout enabled:
diff --git a/drivers/watchdog/softdog.c b/drivers/watchdog/softdog.c
index 100b114e3c3c..bf16ffb4d21e 100644
--- a/drivers/watchdog/softdog.c
+++ b/drivers/watchdog/softdog.c
@@ -48,6 +48,7 @@
 #include <linux/init.h>
 #include <linux/jiffies.h>
 #include <linux/uaccess.h>
+#include <linux/kernel.h>
 
 #define PFX "SoftDog: "
 
@@ -75,6 +76,11 @@ MODULE_PARM_DESC(soft_noboot,
         "Softdog action, set to 1 to ignore reboots, 0 to reboot "
                                         "(default depends on ONLY_TESTING)");
 
+static int soft_panic;
+module_param(soft_panic, int, 0);
+MODULE_PARM_DESC(soft_panic,
+        "Softdog action, set to 1 to panic, 0 to reboot (default=0)");
+
 /*
  *      Our timer
  */
@@ -98,7 +104,10 @@ static void watchdog_fire(unsigned long data)
 
         if (soft_noboot)
                 printk(KERN_CRIT PFX "Triggered - Reboot ignored.\n");
-        else {
+        else if (soft_panic) {
+                printk(KERN_CRIT PFX "Initiating panic.\n");
+                panic("Software Watchdog Timer expired.");
+        } else {
                 printk(KERN_CRIT PFX "Initiating system reboot.\n");
                 emergency_restart();
                 printk(KERN_CRIT PFX "Reboot didn't ?????\n");
@@ -267,7 +276,8 @@ static struct notifier_block softdog_notifier = {
 };
 
 static char banner[] __initdata = KERN_INFO "Software Watchdog Timer: 0.07 "
-        "initialized. soft_noboot=%d soft_margin=%d sec (nowayout= %d)\n";
+        "initialized. soft_noboot=%d soft_margin=%d sec soft_panic=%d "
+        "(nowayout= %d)\n";
 
 static int __init watchdog_init(void)
 {
@@ -298,7 +308,7 @@ static int __init watchdog_init(void)
                 return ret;
         }
 
-        printk(banner, soft_noboot, soft_margin, nowayout);
+        printk(banner, soft_noboot, soft_margin, soft_panic, nowayout);
 
         return 0;
 }
diff --git a/drivers/watchdog/sp5100_tco.c b/drivers/watchdog/sp5100_tco.c
index 1bc493848ed4..87e0527669d8 100644
--- a/drivers/watchdog/sp5100_tco.c
+++ b/drivers/watchdog/sp5100_tco.c
@@ -42,6 +42,7 @@
 #define PFX TCO_MODULE_NAME ": "
 
 /* internal variables */
+static u32 tcobase_phys;
 static void __iomem *tcobase;
 static unsigned int pm_iobase;
 static DEFINE_SPINLOCK(tco_lock);       /* Guards the hardware */
@@ -305,10 +306,18 @@ static unsigned char __devinit sp5100_tco_setupdevice(void)
         /* Low three bits of BASE0 are reserved. */
         val = val << 8 | (inb(SP5100_IO_PM_DATA_REG) & 0xf8);
 
+        if (!request_mem_region_exclusive(val, SP5100_WDT_MEM_MAP_SIZE,
+                                                                "SP5100 TCO")) {
+                printk(KERN_ERR PFX "mmio address 0x%04x already in use\n",
+                        val);
+                goto unreg_region;
+        }
+        tcobase_phys = val;
+
         tcobase = ioremap(val, SP5100_WDT_MEM_MAP_SIZE);
         if (tcobase == 0) {
                 printk(KERN_ERR PFX "failed to get tcobase address\n");
-                goto unreg_region;
+                goto unreg_mem_region;
         }
 
         /* Enable watchdog decode bit */
@@ -346,7 +355,8 @@ static unsigned char __devinit sp5100_tco_setupdevice(void)
         /* Done */
         return 1;
 
-        iounmap(tcobase);
+unreg_mem_region:
+        release_mem_region(tcobase_phys, SP5100_WDT_MEM_MAP_SIZE);
 unreg_region:
         release_region(pm_iobase, SP5100_PM_IOPORTS_SIZE);
 exit:
@@ -401,6 +411,7 @@ static int __devinit sp5100_tco_init(struct platform_device *dev)
 
 exit:
         iounmap(tcobase);
+        release_mem_region(tcobase_phys, SP5100_WDT_MEM_MAP_SIZE);
         release_region(pm_iobase, SP5100_PM_IOPORTS_SIZE);
         return ret;
 }
@@ -414,6 +425,7 @@ static void __devexit sp5100_tco_cleanup(void)
         /* Deregister */
         misc_deregister(&sp5100_tco_miscdev);
         iounmap(tcobase);
+        release_mem_region(tcobase_phys, SP5100_WDT_MEM_MAP_SIZE);
         release_region(pm_iobase, SP5100_PM_IOPORTS_SIZE);
 }
 
diff --git a/drivers/watchdog/sp805_wdt.c b/drivers/watchdog/sp805_wdt.c
index 0a0efe713bc8..0d80e08b6439 100644
--- a/drivers/watchdog/sp805_wdt.c
+++ b/drivers/watchdog/sp805_wdt.c
@@ -90,7 +90,7 @@ static void wdt_setload(unsigned int timeout)
         /*
          * sp805 runs counter with given value twice, after the end of first
          * counter it gives an interrupt and then starts counter again. If
-         * interrupt already occured then it resets the system. This is why
+         * interrupt already occurred then it resets the system. This is why
          * load is half of what should be required.
          */
         load = div_u64(rate, 2) * timeout - 1;