4 files changed, 55 insertions, 26 deletions

diff --git a/drivers/char/vt_ioctl.c b/drivers/char/vt_ioctl.c
index 1fa2da8f4f..c9f2dd620e 100644
--- a/drivers/char/vt_ioctl.c
+++ b/drivers/char/vt_ioctl.c
@@ -1039,10 +1039,22 @@ int vt_waitactive(int vt)
 
         add_wait_queue(&vt_activate_queue, &wait);
         for (;;) {
-                set_current_state(TASK_INTERRUPTIBLE);
                 retval = 0;
-                if (vt == fg_console)
+
+                /*
+                 * Synchronize with redraw_screen(). By acquiring the console
+                 * semaphore we make sure that the console switch is completed
+                 * before we return. If we didn't wait for the semaphore, we
+                 * could return at a point where fg_console has already been
+                 * updated, but the console switch hasn't been completed.
+                 */
+                acquire_console_sem();
+                set_current_state(TASK_INTERRUPTIBLE);
+                if (vt == fg_console) {
+                        release_console_sem();
                         break;
+                }
+                release_console_sem();
                 retval = -EINTR;
                 if (signal_pending(current))
                         break;
diff --git a/drivers/mfd/sm501.c b/drivers/mfd/sm501.c
index c707c8ebc1..b0b4458ae9 100644
--- a/drivers/mfd/sm501.c
+++ b/drivers/mfd/sm501.c
@@ -319,7 +319,7 @@ int sm501_unit_power(struct device *dev, unsigned int unit, unsigned int to)
 
         mode &= 3;              /* get current power mode */
 
-        if (unit > ARRAY_SIZE(sm->unit_power)) {
+        if (unit >= ARRAY_SIZE(sm->unit_power)) {
                 dev_err(dev, "%s: bad unit %d\n", __FUNCTION__, unit);
                 goto already;
         }
diff --git a/drivers/pnp/system.c b/drivers/pnp/system.c
index 2065e74bb6..a8a95540b1 100644
--- a/drivers/pnp/system.c
+++ b/drivers/pnp/system.c
@@ -22,7 +22,7 @@ static const struct pnp_device_id pnp_dev_table[] = {
         {       "",                     0       }
 };
 
-static void reserve_range(char *pnpid, int start, int end, int port)
+static void reserve_range(const char *pnpid, resource_size_t start, resource_size_t end, int port)
 {
         struct resource *res;
         char *regionid;
@@ -32,9 +32,9 @@ static void reserve_range(char *pnpid, int start, int end, int port)
                 return;
         snprintf(regionid, 16, "pnp %s", pnpid);
         if (port)
-                res = request_region(start,end-start+1,regionid);
+                res = request_region(start, end-start+1, regionid);
         else
-                res = request_mem_region(start,end-start+1,regionid);
+                res = request_mem_region(start, end-start+1, regionid);
         if (res == NULL)
                 kfree(regionid);
         else
@@ -45,12 +45,13 @@ static void reserve_range(char *pnpid, int start, int end, int port)
          * have double reservations.
          */
         printk(KERN_INFO
-                "pnp: %s: %s range 0x%x-0x%x %s reserved\n",
-                pnpid, port ? "ioport" : "iomem", start, end,
+                "pnp: %s: %s range 0x%llx-0x%llx %s reserved\n",
+                pnpid, port ? "ioport" : "iomem",
+                (unsigned long long)start, (unsigned long long)end,
                 NULL != res ? "has been" : "could not be");
 }
 
-static void reserve_resources_of_dev(struct pnp_dev *dev)
+static void reserve_resources_of_dev(const struct pnp_dev *dev)
 {
         int i;
 
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index 85bf795abd..7c0d609100 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -59,6 +59,19 @@ struct cmos_rtc {
 
 static const char driver_name[] = "rtc_cmos";
 
+/* The RTC_INTR register may have e.g. RTC_PF set even if RTC_PIE is clear;
+ * always mask it against the irq enable bits in RTC_CONTROL.  Bit values
+ * are the same: PF==PIE, AF=AIE, UF=UIE; so RTC_IRQMASK works with both.
+ */
+#define RTC_IRQMASK     (RTC_PF | RTC_AF | RTC_UF)
+
+static inline int is_intr(u8 rtc_intr)
+{
+        if (!(rtc_intr & RTC_IRQF))
+                return 0;
+        return rtc_intr & RTC_IRQMASK;
+}
+
 /*----------------------------------------------------------------*/
 
 static int cmos_read_time(struct device *dev, struct rtc_time *t)
@@ -188,7 +201,8 @@ static int cmos_set_alarm(struct device *dev, struct rtc_wkalrm *t)
         rtc_control &= ~RTC_AIE;
         CMOS_WRITE(rtc_control, RTC_CONTROL);
         rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
-        if (rtc_intr)
+        rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
+        if (is_intr(rtc_intr))
                 rtc_update_irq(&cmos->rtc->class_dev, 1, rtc_intr);
 
         /* update alarm */
@@ -207,7 +221,8 @@ static int cmos_set_alarm(struct device *dev, struct rtc_wkalrm *t)
                 rtc_control |= RTC_AIE;
                 CMOS_WRITE(rtc_control, RTC_CONTROL);
                 rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
-                if (rtc_intr)
+                rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
+                if (is_intr(rtc_intr))
                         rtc_update_irq(&cmos->rtc->class_dev, 1, rtc_intr);
         }
 
@@ -287,7 +302,8 @@ cmos_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
         }
         CMOS_WRITE(rtc_control, RTC_CONTROL);
         rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
-        if (rtc_intr)
+        rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
+        if (is_intr(rtc_intr))
                 rtc_update_irq(&cmos->rtc->class_dev, 1, rtc_intr);
         spin_unlock_irqrestore(&rtc_lock, flags);
         return 0;
@@ -353,12 +369,10 @@ static irqreturn_t cmos_interrupt(int irq, void *p)
 
         spin_lock(&rtc_lock);
         irqstat = CMOS_READ(RTC_INTR_FLAGS);
+        irqstat &= (CMOS_READ(RTC_CONTROL) & RTC_IRQMASK) | RTC_IRQF;
         spin_unlock(&rtc_lock);
 
-        if (irqstat) {
-                /* NOTE: irqstat may have e.g. RTC_PF set
-                 * even when RTC_PIE is clear...
-                 */
+        if (is_intr(irqstat)) {
                 rtc_update_irq(p, 1, irqstat);
                 return IRQ_HANDLED;
         } else
@@ -525,25 +539,26 @@ static int cmos_suspend(struct device *dev, pm_message_t mesg)
 {
         struct cmos_rtc *cmos = dev_get_drvdata(dev);
         int             do_wake = device_may_wakeup(dev);
-        unsigned char   tmp, irqstat;
+        unsigned char   tmp;
 
         /* only the alarm might be a wakeup event source */
         spin_lock_irq(&rtc_lock);
         cmos->suspend_ctrl = tmp = CMOS_READ(RTC_CONTROL);
         if (tmp & (RTC_PIE|RTC_AIE|RTC_UIE)) {
+                unsigned char   irqstat;
+
                 if (do_wake)
                         tmp &= ~(RTC_PIE|RTC_UIE);
                 else
                         tmp &= ~(RTC_PIE|RTC_AIE|RTC_UIE);
                 CMOS_WRITE(tmp, RTC_CONTROL);
                 irqstat = CMOS_READ(RTC_INTR_FLAGS);
-        } else
-                irqstat = 0;
+                irqstat &= (tmp & RTC_IRQMASK) | RTC_IRQF;
+                if (is_intr(irqstat))
+                        rtc_update_irq(&cmos->rtc->class_dev, 1, irqstat);
+        }
         spin_unlock_irq(&rtc_lock);
 
-        if (irqstat)
-                rtc_update_irq(&cmos->rtc->class_dev, 1, irqstat);
-
         /* ACPI HOOK:  enable ACPI_EVENT_RTC when (tmp & RTC_AIE)
          * ... it'd be best if we could do that under rtc_lock.
          */
@@ -573,9 +588,10 @@ static int cmos_resume(struct device *dev)
                 spin_lock_irq(&rtc_lock);
                 CMOS_WRITE(tmp, RTC_CONTROL);
                 tmp = CMOS_READ(RTC_INTR_FLAGS);
-                spin_unlock_irq(&rtc_lock);
-                if (tmp)
+                tmp &= (cmos->suspend_ctrl & RTC_IRQMASK) | RTC_IRQF;
+                if (is_intr(tmp))
                         rtc_update_irq(&cmos->rtc->class_dev, 1, tmp);
+                spin_unlock_irq(&rtc_lock);
         }
 
         pr_debug("%s: resume, ctrl %02x\n",
@@ -594,7 +610,7 @@ static int cmos_resume(struct device *dev)
 /*----------------------------------------------------------------*/
 
 /* The "CMOS" RTC normally lives on the platform_bus.  On ACPI systems,
- * the device node may alternatively be created as a PNP device.
+ * the device node will always be created as a PNPACPI device.
  */
 
 #ifdef  CONFIG_PNPACPI
@@ -673,7 +689,7 @@ module_exit(cmos_exit);
 /*----------------------------------------------------------------*/
 
 /* Platform setup should have set up an RTC device, when PNPACPI is
- * unavailable ... this is the normal case, common even on PCs.
+ * unavailable ... this could happen even on (older) PCs.
  */
 
 static int __init cmos_platform_probe(struct platform_device *pdev)