Merge branch 'master' of /home/davem/src/GIT/linux-2.6/

Conflicts:
	MAINTAINERS

1 files changed, 77 insertions, 78 deletions

diff --git a/drivers/watchdog/i6300esb.c b/drivers/watchdog/i6300esb.c
index 2dbe83570d65..7ba0b11ec525 100644
--- a/drivers/watchdog/i6300esb.c
+++ b/drivers/watchdog/i6300esb.c
@@ -52,10 +52,10 @@
 #define ESB_LOCK_REG    0x68            /* WDT lock register                 */
 
 /* Memory mapped registers */
-#define ESB_TIMER1_REG  BASEADDR + 0x00 /* Timer1 value after each reset     */
-#define ESB_TIMER2_REG  BASEADDR + 0x04 /* Timer2 value after each reset     */
-#define ESB_GINTSR_REG  BASEADDR + 0x08 /* General Interrupt Status Register */
-#define ESB_RELOAD_REG  BASEADDR + 0x0c /* Reload register                   */
+#define ESB_TIMER1_REG (BASEADDR + 0x00)/* Timer1 value after each reset     */
+#define ESB_TIMER2_REG (BASEADDR + 0x04)/* Timer2 value after each reset     */
+#define ESB_GINTSR_REG (BASEADDR + 0x08)/* General Interrupt Status Register */
+#define ESB_RELOAD_REG (BASEADDR + 0x0c)/* Reload register                   */
 
 /* Lock register bits */
 #define ESB_WDT_FUNC    (0x01 << 2)   /* Watchdog functionality            */
@@ -68,6 +68,7 @@
 #define ESB_WDT_INTTYPE (0x11 << 0)   /* Interrupt type on timer1 timeout  */
 
 /* Reload register bits */
+#define ESB_WDT_TIMEOUT (0x01 << 9)    /* Watchdog timed out                */
 #define ESB_WDT_RELOAD  (0x01 << 8)    /* prevent timeout                   */
 
 /* Magic constants */
@@ -87,7 +88,6 @@ static struct platform_device *esb_platform_device;
 /* 30 sec default heartbeat (1 < heartbeat < 2*1023) */
 #define WATCHDOG_HEARTBEAT 30
 static int heartbeat = WATCHDOG_HEARTBEAT;  /* in seconds */
-
 module_param(heartbeat, int, 0);
 MODULE_PARM_DESC(heartbeat,
                 "Watchdog heartbeat in seconds. (1<heartbeat<2046, default="
@@ -123,7 +123,7 @@ static int esb_timer_start(void)
         esb_unlock_registers();
         writew(ESB_WDT_RELOAD, ESB_RELOAD_REG);
         /* Enable or Enable + Lock? */
-        val = 0x02 | (nowayout ? 0x01 : 0x00);
+        val = ESB_WDT_ENABLE | (nowayout ? ESB_WDT_LOCK : 0x00);
         pci_write_config_byte(esb_pci, ESB_LOCK_REG, val);
         spin_unlock(&esb_lock);
         return 0;
@@ -143,7 +143,7 @@ static int esb_timer_stop(void)
         spin_unlock(&esb_lock);
 
         /* Returns 0 if the timer was disabled, non-zero otherwise */
-        return (val & 0x01);
+        return val & ESB_WDT_ENABLE;
 }
 
 static void esb_timer_keepalive(void)
@@ -190,18 +190,6 @@ static int esb_timer_set_heartbeat(int time)
         return 0;
 }
 
-static int esb_timer_read(void)
-{
-        u32 count;
-
-        /* This isn't documented, and doesn't take into
-         * acount which stage is running, but it looks
-         * like a 20 bit count down, so we might as well report it.
-         */
-        pci_read_config_dword(esb_pci, 0x64, &count);
-        return (int)count;
-}
-
 /*
  *      /dev/watchdog handling
  */
@@ -282,7 +270,7 @@ static long esb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                                         sizeof(ident)) ? -EFAULT : 0;
 
         case WDIOC_GETSTATUS:
-                return put_user(esb_timer_read(), p);
+                return put_user(0, p);
 
         case WDIOC_GETBOOTSTATUS:
                 return put_user(triggered, p);
@@ -362,8 +350,6 @@ MODULE_DEVICE_TABLE(pci, esb_pci_tbl);
 
 static unsigned char __devinit esb_getdevice(void)
 {
-        u8 val1;
-        unsigned short val2;
         /*
          *      Find the PCI device
          */
@@ -371,66 +357,79 @@ static unsigned char __devinit esb_getdevice(void)
         esb_pci = pci_get_device(PCI_VENDOR_ID_INTEL,
                                         PCI_DEVICE_ID_INTEL_ESB_9, NULL);
 
-        if (esb_pci) {
-                if (pci_enable_device(esb_pci)) {
-                        printk(KERN_ERR PFX "failed to enable device\n");
-                        goto err_devput;
-                }
+        if (!esb_pci)
+                return 0;
 
-                if (pci_request_region(esb_pci, 0, ESB_MODULE_NAME)) {
-                        printk(KERN_ERR PFX "failed to request region\n");
-                        goto err_disable;
-                }
+        if (pci_enable_device(esb_pci)) {
+                printk(KERN_ERR PFX "failed to enable device\n");
+                goto err_devput;
+        }
 
-                BASEADDR = pci_ioremap_bar(esb_pci, 0);
-                if (BASEADDR == NULL) {
-                        /* Something's wrong here, BASEADDR has to be set */
-                        printk(KERN_ERR PFX "failed to get BASEADDR\n");
-                        goto err_release;
-                }
+        if (pci_request_region(esb_pci, 0, ESB_MODULE_NAME)) {
+                printk(KERN_ERR PFX "failed to request region\n");
+                goto err_disable;
+        }
 
-                /*
-                 * The watchdog has two timers, it can be setup so that the
-                 * expiry of timer1 results in an interrupt and the expiry of
-                 * timer2 results in a reboot. We set it to not generate
-                 * any interrupts as there is not much we can do with it
-                 * right now.
-                 *
-                 * We also enable reboots and set the timer frequency to
-                 * the PCI clock divided by 2^15 (approx 1KHz).
-                 */
-                pci_write_config_word(esb_pci, ESB_CONFIG_REG, 0x0003);
-
-                /* Check that the WDT isn't already locked */
-                pci_read_config_byte(esb_pci, ESB_LOCK_REG, &val1);
-                if (val1 & ESB_WDT_LOCK)
-                        printk(KERN_WARNING PFX "nowayout already set\n");
-
-                /* Set the timer to watchdog mode and disable it for now */
-                pci_write_config_byte(esb_pci, ESB_LOCK_REG, 0x00);
-
-                /* Check if the watchdog was previously triggered */
-                esb_unlock_registers();
-                val2 = readw(ESB_RELOAD_REG);
-                triggered = (val2 & (0x01 << 9) >> 9);
-
-                /* Reset trigger flag and timers */
-                esb_unlock_registers();
-                writew((0x11 << 8), ESB_RELOAD_REG);
-
-                /* Done */
-                return 1;
+        BASEADDR = pci_ioremap_bar(esb_pci, 0);
+        if (BASEADDR == NULL) {
+                /* Something's wrong here, BASEADDR has to be set */
+                printk(KERN_ERR PFX "failed to get BASEADDR\n");
+                goto err_release;
+        }
+
+        /* Done */
+        return 1;
 
 err_release:
-                pci_release_region(esb_pci, 0);
+        pci_release_region(esb_pci, 0);
 err_disable:
-                pci_disable_device(esb_pci);
+        pci_disable_device(esb_pci);
 err_devput:
-                pci_dev_put(esb_pci);
-        }
+        pci_dev_put(esb_pci);
         return 0;
 }
 
+static void __devinit esb_initdevice(void)
+{
+        u8 val1;
+        u16 val2;
+
+        /*
+         * Config register:
+         * Bit    5 : 0 = Enable WDT_OUTPUT
+         * Bit    2 : 0 = set the timer frequency to the PCI clock
+         * divided by 2^15 (approx 1KHz).
+         * Bits 1:0 : 11 = WDT_INT_TYPE Disabled.
+         * The watchdog has two timers, it can be setup so that the
+         * expiry of timer1 results in an interrupt and the expiry of
+         * timer2 results in a reboot. We set it to not generate
+         * any interrupts as there is not much we can do with it
+         * right now.
+         */
+        pci_write_config_word(esb_pci, ESB_CONFIG_REG, 0x0003);
+
+        /* Check that the WDT isn't already locked */
+        pci_read_config_byte(esb_pci, ESB_LOCK_REG, &val1);
+        if (val1 & ESB_WDT_LOCK)
+                printk(KERN_WARNING PFX "nowayout already set\n");
+
+        /* Set the timer to watchdog mode and disable it for now */
+        pci_write_config_byte(esb_pci, ESB_LOCK_REG, 0x00);
+
+        /* Check if the watchdog was previously triggered */
+        esb_unlock_registers();
+        val2 = readw(ESB_RELOAD_REG);
+        if (val2 & ESB_WDT_TIMEOUT)
+                triggered = WDIOF_CARDRESET;
+
+        /* Reset WDT_TIMEOUT flag and timers */
+        esb_unlock_registers();
+        writew((ESB_WDT_TIMEOUT | ESB_WDT_RELOAD), ESB_RELOAD_REG);
+
+        /* And set the correct timeout value */
+        esb_timer_set_heartbeat(heartbeat);
+}
+
 static int __devinit esb_probe(struct platform_device *dev)
 {
         int ret;
@@ -441,13 +440,17 @@ static int __devinit esb_probe(struct platform_device *dev)
 
         /* Check that the heartbeat value is within it's range;
            if not reset to the default */
-        if (esb_timer_set_heartbeat(heartbeat)) {
-                esb_timer_set_heartbeat(WATCHDOG_HEARTBEAT);
+        if (heartbeat < 0x1 || heartbeat > 2 * 0x03ff) {
+                heartbeat = WATCHDOG_HEARTBEAT;
                 printk(KERN_INFO PFX
                         "heartbeat value must be 1<heartbeat<2046, using %d\n",
                                                                 heartbeat);
         }
 
+        /* Initialize the watchdog and make sure it does not run */
+        esb_initdevice();
+
+        /* Register the watchdog so that userspace has access to it */
         ret = misc_register(&esb_miscdev);
         if (ret != 0) {
                 printk(KERN_ERR PFX
@@ -455,7 +458,6 @@ static int __devinit esb_probe(struct platform_device *dev)
                                                         WATCHDOG_MINOR, ret);
                 goto err_unmap;
         }
-        esb_timer_stop();
         printk(KERN_INFO PFX
                 "initialized (0x%p). heartbeat=%d sec (nowayout=%d)\n",
                                                 BASEADDR, heartbeat, nowayout);
@@ -463,11 +465,8 @@ static int __devinit esb_probe(struct platform_device *dev)
 
 err_unmap:
         iounmap(BASEADDR);
-/* err_release: */
         pci_release_region(esb_pci, 0);
-/* err_disable: */
         pci_disable_device(esb_pci);
-/* err_devput: */
         pci_dev_put(esb_pci);
         return ret;
 }