12 files changed, 103 insertions, 93 deletions

diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index e61d4f8e62a5..5f2027d782e8 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -79,7 +79,7 @@ enum {
         EC_FLAGS_GPE_STORM,             /* GPE storm detected */
         EC_FLAGS_HANDLERS_INSTALLED,    /* Handlers for GPE and
                                          * OpReg are installed */
-        EC_FLAGS_FROZEN,                /* Transactions are suspended */
+        EC_FLAGS_BLOCKED,               /* Transactions are blocked */
 };
 
 /* If we find an EC via the ECDT, we need to keep a ptr to its context */
@@ -293,7 +293,7 @@ static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
         if (t->rdata)
                 memset(t->rdata, 0, t->rlen);
         mutex_lock(&ec->lock);
-        if (test_bit(EC_FLAGS_FROZEN, &ec->flags)) {
+        if (test_bit(EC_FLAGS_BLOCKED, &ec->flags)) {
                 status = -EINVAL;
                 goto unlock;
         }
@@ -459,7 +459,7 @@ int ec_transaction(u8 command,
 
 EXPORT_SYMBOL(ec_transaction);
 
-void acpi_ec_suspend_transactions(void)
+void acpi_ec_block_transactions(void)
 {
         struct acpi_ec *ec = first_ec;
 
@@ -468,11 +468,11 @@ void acpi_ec_suspend_transactions(void)
 
         mutex_lock(&ec->lock);
         /* Prevent transactions from being carried out */
-        set_bit(EC_FLAGS_FROZEN, &ec->flags);
+        set_bit(EC_FLAGS_BLOCKED, &ec->flags);
         mutex_unlock(&ec->lock);
 }
 
-void acpi_ec_resume_transactions(void)
+void acpi_ec_unblock_transactions(void)
 {
         struct acpi_ec *ec = first_ec;
 
@@ -481,10 +481,20 @@ void acpi_ec_resume_transactions(void)
 
         mutex_lock(&ec->lock);
         /* Allow transactions to be carried out again */
-        clear_bit(EC_FLAGS_FROZEN, &ec->flags);
+        clear_bit(EC_FLAGS_BLOCKED, &ec->flags);
         mutex_unlock(&ec->lock);
 }
 
+void acpi_ec_unblock_transactions_early(void)
+{
+        /*
+         * Allow transactions to happen again (this function is called from
+         * atomic context during wakeup, so we don't need to acquire the mutex).
+         */
+        if (first_ec)
+                clear_bit(EC_FLAGS_BLOCKED, &first_ec->flags);
+}
+
 static int acpi_ec_query_unlocked(struct acpi_ec *ec, u8 * data)
 {
         int result;
diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h
index e28411367239..f8f190ec066e 100644
--- a/drivers/acpi/internal.h
+++ b/drivers/acpi/internal.h
@@ -49,8 +49,9 @@ void acpi_early_processor_set_pdc(void);
 int acpi_ec_init(void);
 int acpi_ec_ecdt_probe(void);
 int acpi_boot_ec_enable(void);
-void acpi_ec_suspend_transactions(void);
-void acpi_ec_resume_transactions(void);
+void acpi_ec_block_transactions(void);
+void acpi_ec_unblock_transactions(void);
+void acpi_ec_unblock_transactions_early(void);
 
 /*--------------------------------------------------------------------------
                                   Suspend/Resume
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index 2e8c27d48f2b..b1b385692f46 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -80,7 +80,7 @@ module_param(nocst, uint, 0000);
 static unsigned int latency_factor __read_mostly = 2;
 module_param(latency_factor, uint, 0644);
 
-static s64 us_to_pm_timer_ticks(s64 t)
+static u64 us_to_pm_timer_ticks(s64 t)
 {
         return div64_u64(t * PM_TIMER_FREQUENCY, 1000000);
 }
@@ -731,10 +731,10 @@ static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset)
 
                 seq_puts(seq, "demotion[--] ");
 
-                seq_printf(seq, "latency[%03d] usage[%08d] duration[%020llu]\n",
+                seq_printf(seq, "latency[%03d] usage[%08d] duration[%020Lu]\n",
                            pr->power.states[i].latency,
                            pr->power.states[i].usage,
-                           (unsigned long long)pr->power.states[i].time);
+                           us_to_pm_timer_ticks(pr->power.states[i].time));
         }
 
       end:
@@ -861,7 +861,6 @@ static int acpi_idle_enter_simple(struct cpuidle_device *dev,
         ktime_t  kt1, kt2;
         s64 idle_time_ns;
         s64 idle_time;
-        s64 sleep_ticks = 0;
 
         pr = __get_cpu_var(processors);
 
@@ -906,8 +905,6 @@ static int acpi_idle_enter_simple(struct cpuidle_device *dev,
         idle_time = idle_time_ns;
         do_div(idle_time, NSEC_PER_USEC);
 
-        sleep_ticks = us_to_pm_timer_ticks(idle_time);
-
         /* Tell the scheduler how much we idled: */
         sched_clock_idle_wakeup_event(idle_time_ns);
 
@@ -918,7 +915,7 @@ static int acpi_idle_enter_simple(struct cpuidle_device *dev,
         cx->usage++;
 
         lapic_timer_state_broadcast(pr, cx, 0);
-        cx->time += sleep_ticks;
+        cx->time += idle_time;
         return idle_time;
 }
 
@@ -940,7 +937,6 @@ static int acpi_idle_enter_bm(struct cpuidle_device *dev,
         ktime_t  kt1, kt2;
         s64 idle_time_ns;
         s64 idle_time;
-        s64 sleep_ticks = 0;
 
 
         pr = __get_cpu_var(processors);
@@ -1022,11 +1018,10 @@ static int acpi_idle_enter_bm(struct cpuidle_device *dev,
                 spin_unlock(&c3_lock);
         }
         kt2 = ktime_get_real();
-        idle_time_ns = ktime_to_us(ktime_sub(kt2, kt1));
+        idle_time_ns = ktime_to_ns(ktime_sub(kt2, kt1));
         idle_time = idle_time_ns;
         do_div(idle_time, NSEC_PER_USEC);
 
-        sleep_ticks = us_to_pm_timer_ticks(idle_time);
         /* Tell the scheduler how much we idled: */
         sched_clock_idle_wakeup_event(idle_time_ns);
 
@@ -1037,7 +1032,7 @@ static int acpi_idle_enter_bm(struct cpuidle_device *dev,
         cx->usage++;
 
         lapic_timer_state_broadcast(pr, cx, 0);
-        cx->time += sleep_ticks;
+        cx->time += idle_time;
         return idle_time;
 }
 
diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c
index 4ab2275b4461..3fb4bdea7e06 100644
--- a/drivers/acpi/sleep.c
+++ b/drivers/acpi/sleep.c
@@ -94,11 +94,13 @@ void __init acpi_old_suspend_ordering(void)
 }
 
 /**
- *      acpi_pm_disable_gpes - Disable the GPEs.
+ * acpi_pm_freeze - Disable the GPEs and suspend EC transactions.
  */
-static int acpi_pm_disable_gpes(void)
+static int acpi_pm_freeze(void)
 {
         acpi_disable_all_gpes();
+        acpi_os_wait_events_complete(NULL);
+        acpi_ec_block_transactions();
         return 0;
 }
 
@@ -126,7 +128,8 @@ static int acpi_pm_prepare(void)
         int error = __acpi_pm_prepare();
 
         if (!error)
-                acpi_disable_all_gpes();
+                acpi_pm_freeze();
+
         return error;
 }
 
@@ -256,6 +259,8 @@ static int acpi_suspend_enter(suspend_state_t pm_state)
          * acpi_leave_sleep_state will reenable specific GPEs later
          */
         acpi_disable_all_gpes();
+        /* Allow EC transactions to happen. */
+        acpi_ec_unblock_transactions_early();
 
         local_irq_restore(flags);
         printk(KERN_DEBUG "Back to C!\n");
@@ -267,6 +272,12 @@ static int acpi_suspend_enter(suspend_state_t pm_state)
         return ACPI_SUCCESS(status) ? 0 : -EFAULT;
 }
 
+static void acpi_suspend_finish(void)
+{
+        acpi_ec_unblock_transactions();
+        acpi_pm_finish();
+}
+
 static int acpi_suspend_state_valid(suspend_state_t pm_state)
 {
         u32 acpi_state;
@@ -288,7 +299,7 @@ static struct platform_suspend_ops acpi_suspend_ops = {
         .begin = acpi_suspend_begin,
         .prepare_late = acpi_pm_prepare,
         .enter = acpi_suspend_enter,
-        .wake = acpi_pm_finish,
+        .wake = acpi_suspend_finish,
         .end = acpi_pm_end,
 };
 
@@ -314,9 +325,9 @@ static int acpi_suspend_begin_old(suspend_state_t pm_state)
 static struct platform_suspend_ops acpi_suspend_ops_old = {
         .valid = acpi_suspend_state_valid,
         .begin = acpi_suspend_begin_old,
-        .prepare_late = acpi_pm_disable_gpes,
+        .prepare_late = acpi_pm_freeze,
         .enter = acpi_suspend_enter,
-        .wake = acpi_pm_finish,
+        .wake = acpi_suspend_finish,
         .end = acpi_pm_end,
         .recover = acpi_pm_finish,
 };
@@ -433,6 +444,7 @@ static int acpi_hibernation_enter(void)
 static void acpi_hibernation_finish(void)
 {
         hibernate_nvs_free();
+        acpi_ec_unblock_transactions();
         acpi_pm_finish();
 }
 
@@ -453,19 +465,13 @@ static void acpi_hibernation_leave(void)
         }
         /* Restore the NVS memory area */
         hibernate_nvs_restore();
+        /* Allow EC transactions to happen. */
+        acpi_ec_unblock_transactions_early();
 }
 
-static int acpi_pm_pre_restore(void)
-{
-        acpi_disable_all_gpes();
-        acpi_os_wait_events_complete(NULL);
-        acpi_ec_suspend_transactions();
-        return 0;
-}
-
-static void acpi_pm_restore_cleanup(void)
+static void acpi_pm_thaw(void)
 {
-        acpi_ec_resume_transactions();
+        acpi_ec_unblock_transactions();
         acpi_enable_all_runtime_gpes();
 }
 
@@ -477,8 +483,8 @@ static struct platform_hibernation_ops acpi_hibernation_ops = {
         .prepare = acpi_pm_prepare,
         .enter = acpi_hibernation_enter,
         .leave = acpi_hibernation_leave,
-        .pre_restore = acpi_pm_pre_restore,
-        .restore_cleanup = acpi_pm_restore_cleanup,
+        .pre_restore = acpi_pm_freeze,
+        .restore_cleanup = acpi_pm_thaw,
 };
 
 /**
@@ -510,12 +516,9 @@ static int acpi_hibernation_begin_old(void)
 
 static int acpi_hibernation_pre_snapshot_old(void)
 {
-        int error = acpi_pm_disable_gpes();
-
-        if (!error)
-                hibernate_nvs_save();
-
-        return error;
+        acpi_pm_freeze();
+        hibernate_nvs_save();
+        return 0;
 }
 
 /*
@@ -527,11 +530,11 @@ static struct platform_hibernation_ops acpi_hibernation_ops_old = {
         .end = acpi_pm_end,
         .pre_snapshot = acpi_hibernation_pre_snapshot_old,
         .finish = acpi_hibernation_finish,
-        .prepare = acpi_pm_disable_gpes,
+        .prepare = acpi_pm_freeze,
         .enter = acpi_hibernation_enter,
         .leave = acpi_hibernation_leave,
-        .pre_restore = acpi_pm_pre_restore,
-        .restore_cleanup = acpi_pm_restore_cleanup,
+        .pre_restore = acpi_pm_freeze,
+        .restore_cleanup = acpi_pm_thaw,
         .recover = acpi_pm_finish,
 };
 #endif /* CONFIG_HIBERNATION */
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index f09fc0e2062d..7cfcc629a7fd 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -1123,6 +1123,7 @@ source "drivers/s390/char/Kconfig"
 
 config RAMOOPS
         tristate "Log panic/oops to a RAM buffer"
+        depends on HAS_IOMEM
         default n
         help
           This enables panic and oops messages to be logged to a circular
diff --git a/drivers/misc/vmware_balloon.c b/drivers/misc/vmware_balloon.c
index db9cd0240c6f..2a1e804a71aa 100644
--- a/drivers/misc/vmware_balloon.c
+++ b/drivers/misc/vmware_balloon.c
@@ -45,7 +45,7 @@
 
 MODULE_AUTHOR("VMware, Inc.");
 MODULE_DESCRIPTION("VMware Memory Control (Balloon) Driver");
-MODULE_VERSION("1.2.1.0-K");
+MODULE_VERSION("1.2.1.1-k");
 MODULE_ALIAS("dmi:*:svnVMware*:*");
 MODULE_ALIAS("vmware_vmmemctl");
 MODULE_LICENSE("GPL");
@@ -101,6 +101,8 @@ MODULE_LICENSE("GPL");
 /* Maximum number of page allocations without yielding processor */
 #define VMW_BALLOON_YIELD_THRESHOLD     1024
 
+/* Maximum number of refused pages we accumulate during inflation cycle */
+#define VMW_BALLOON_MAX_REFUSED         16
 
 /*
  * Hypervisor communication port definitions.
@@ -183,6 +185,7 @@ struct vmballoon {
 
         /* transient list of non-balloonable pages */
         struct list_head refused_pages;
+        unsigned int n_refused_pages;
 
         /* balloon size in pages */
         unsigned int size;
@@ -428,14 +431,21 @@ static int vmballoon_reserve_page(struct vmballoon *b, bool can_sleep)
                 /* inform monitor */
                 locked = vmballoon_send_lock_page(b, page_to_pfn(page));
                 if (!locked) {
+                        STATS_INC(b->stats.refused_alloc);
+
                         if (b->reset_required) {
                                 __free_page(page);
                                 return -EIO;
                         }
 
-                        /* place on list of non-balloonable pages, retry allocation */
+                        /*
+                         * Place page on the list of non-balloonable pages
+                         * and retry allocation, unless we already accumulated
+                         * too many of them, in which case take a breather.
+                         */
                         list_add(&page->lru, &b->refused_pages);
-                        STATS_INC(b->stats.refused_alloc);
+                        if (++b->n_refused_pages >= VMW_BALLOON_MAX_REFUSED)
+                                return -EIO;
                 }
         } while (!locked);
 
@@ -483,6 +493,8 @@ static void vmballoon_release_refused_pages(struct vmballoon *b)
                 __free_page(page);
                 STATS_INC(b->stats.refused_free);
         }
+
+        b->n_refused_pages = 0;
 }
 
 /*
diff --git a/drivers/mmc/host/omap.c b/drivers/mmc/host/omap.c
index 2b281680e320..d98ddcfac5e5 100644
--- a/drivers/mmc/host/omap.c
+++ b/drivers/mmc/host/omap.c
@@ -1157,7 +1157,6 @@ static void mmc_omap_start_request(struct mmc_omap_host *host,
         mmc_omap_start_command(host, req->cmd);
         if (host->dma_in_use)
                 omap_start_dma(host->dma_ch);
-        BUG_ON(irqs_disabled());
 }
 
 static void mmc_omap_request(struct mmc_host *mmc, struct mmc_request *req)
diff --git a/drivers/rtc/rtc-s3c.c b/drivers/rtc/rtc-s3c.c
index e5972b2c17b7..70b68d35f969 100644
--- a/drivers/rtc/rtc-s3c.c
+++ b/drivers/rtc/rtc-s3c.c
@@ -495,8 +495,6 @@ static int __devinit s3c_rtc_probe(struct platform_device *pdev)
         pr_debug("s3c2410_rtc: RTCCON=%02x\n",
                  readb(s3c_rtc_base + S3C2410_RTCCON));
 
-        s3c_rtc_setfreq(&pdev->dev, 1);
-
         device_init_wakeup(&pdev->dev, 1);
 
         /* register RTC and exit */
@@ -510,14 +508,17 @@ static int __devinit s3c_rtc_probe(struct platform_device *pdev)
                 goto err_nortc;
         }
 
+        s3c_rtc_cpu_type = platform_get_device_id(pdev)->driver_data;
+
         if (s3c_rtc_cpu_type == TYPE_S3C64XX)
                 rtc->max_user_freq = 32768;
         else
                 rtc->max_user_freq = 128;
 
-        s3c_rtc_cpu_type = platform_get_device_id(pdev)->driver_data;
-
         platform_set_drvdata(pdev, rtc);
+
+        s3c_rtc_setfreq(&pdev->dev, 1);
+
         return 0;
 
  err_nortc:
diff --git a/drivers/sfi/sfi_core.c b/drivers/sfi/sfi_core.c
index 005195958647..ceba593dc84f 100644
--- a/drivers/sfi/sfi_core.c
+++ b/drivers/sfi/sfi_core.c
@@ -441,8 +441,10 @@ struct sfi_table_attr __init *sfi_sysfs_install_table(u64 pa)
 
         ret = sysfs_create_bin_file(tables_kobj,
                                   &tbl_attr->attr);
-        if (ret)
+        if (ret) {
                 kfree(tbl_attr);
+                tbl_attr = NULL;
+        }
 
         sfi_unmap_table(th);
         return tbl_attr;
diff --git a/drivers/usb/gadget/f_audio.c b/drivers/usb/gadget/f_audio.c
index 43bf44514c41..b91115f84b13 100644
--- a/drivers/usb/gadget/f_audio.c
+++ b/drivers/usb/gadget/f_audio.c
@@ -101,7 +101,7 @@ static struct uac_feature_unit_descriptor_0 feature_unit_desc = {
 static struct usb_audio_control mute_control = {
         .list = LIST_HEAD_INIT(mute_control.list),
         .name = "Mute Control",
-        .type = UAC_MUTE_CONTROL,
+        .type = UAC_FU_MUTE,
         /* Todo: add real Mute control code */
         .set = generic_set_cmd,
         .get = generic_get_cmd,
@@ -110,7 +110,7 @@ static struct usb_audio_control mute_control = {
 static struct usb_audio_control volume_control = {
         .list = LIST_HEAD_INIT(volume_control.list),
         .name = "Volume Control",
-        .type = UAC_VOLUME_CONTROL,
+        .type = UAC_FU_VOLUME,
         /* Todo: add real Volume control code */
         .set = generic_set_cmd,
         .get = generic_get_cmd,
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index 1e6fec487973..3d94a1471724 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -8,6 +8,9 @@ menu "Graphics support"
 config HAVE_FB_ATMEL
         bool
 
+config HAVE_FB_IMX
+        bool
+
 source "drivers/char/agp/Kconfig"
 
 source "drivers/gpu/vga/Kconfig"
@@ -400,9 +403,6 @@ config FB_SA1100
           If you plan to use the LCD display with your SA-1100 system, say
           Y here.
 
-config HAVE_FB_IMX
-        bool
-
 config FB_IMX
         tristate "Motorola i.MX LCD support"
         depends on FB && (HAVE_FB_IMX || ARCH_MX1 || ARCH_MX2)
diff --git a/drivers/video/fb_defio.c b/drivers/video/fb_defio.c
index 073c9b408cf7..6b93ef93cb12 100644
--- a/drivers/video/fb_defio.c
+++ b/drivers/video/fb_defio.c
@@ -100,6 +100,16 @@ static int fb_deferred_io_mkwrite(struct vm_area_struct *vma,
         /* protect against the workqueue changing the page list */
         mutex_lock(&fbdefio->lock);
 
+        /*
+         * We want the page to remain locked from ->page_mkwrite until
+         * the PTE is marked dirty to avoid page_mkclean() being called
+         * before the PTE is updated, which would leave the page ignored
+         * by defio.
+         * Do this by locking the page here and informing the caller
+         * about it with VM_FAULT_LOCKED.
+         */
+        lock_page(page);
+
         /* we loop through the pagelist before adding in order
         to keep the pagelist sorted */
         list_for_each_entry(cur, &fbdefio->pagelist, lru) {
@@ -121,7 +131,7 @@ page_already_added:
 
         /* come back after delay to process the deferred IO */
         schedule_delayed_work(&info->deferred_work, fbdefio->delay);
-        return 0;
+        return VM_FAULT_LOCKED;
 }
 
 static const struct vm_operations_struct fb_deferred_io_vm_ops = {
@@ -155,41 +165,25 @@ static void fb_deferred_io_work(struct work_struct *work)
 {
         struct fb_info *info = container_of(work, struct fb_info,
                                                 deferred_work.work);
+        struct list_head *node, *next;
+        struct page *cur;
         struct fb_deferred_io *fbdefio = info->fbdefio;
-        struct page *page, *tmp_page;
-        struct list_head *node, *tmp_node;
-        struct list_head non_dirty;
-
-        INIT_LIST_HEAD(&non_dirty);
 
         /* here we mkclean the pages, then do all deferred IO */
         mutex_lock(&fbdefio->lock);
-        list_for_each_entry_safe(page, tmp_page, &fbdefio->pagelist, lru) {
-                lock_page(page);
-                /*
-                 * The workqueue callback can be triggered after a
-                 * ->page_mkwrite() call but before the PTE has been marked
-                 * dirty. In this case page_mkclean() won't "rearm" the page.
-                 *
-                 * To avoid this, remove those "non-dirty" pages from the
-                 * pagelist before calling the driver's callback, then add
-                 * them back to get processed on the next work iteration.
-                 * At that time, their PTEs will hopefully be dirty for real.
-                 */
-                if (!page_mkclean(page))
-                        list_move_tail(&page->lru, &non_dirty);
-                unlock_page(page);
+        list_for_each_entry(cur, &fbdefio->pagelist, lru) {
+                lock_page(cur);
+                page_mkclean(cur);
+                unlock_page(cur);
         }
 
         /* driver's callback with pagelist */
         fbdefio->deferred_io(info, &fbdefio->pagelist);
 
-        /* clear the list... */
-        list_for_each_safe(node, tmp_node, &fbdefio->pagelist) {
+        /* clear the list */
+        list_for_each_safe(node, next, &fbdefio->pagelist) {
                 list_del(node);
         }
-        /* ... and add back the "non-dirty" pages to the list */
-        list_splice_tail(&non_dirty, &fbdefio->pagelist);
         mutex_unlock(&fbdefio->lock);
 }
 
@@ -218,7 +212,6 @@ EXPORT_SYMBOL_GPL(fb_deferred_io_open);
 void fb_deferred_io_cleanup(struct fb_info *info)
 {
         struct fb_deferred_io *fbdefio = info->fbdefio;
-        struct list_head *node, *tmp_node;
         struct page *page;
         int i;
 
@@ -226,13 +219,6 @@ void fb_deferred_io_cleanup(struct fb_info *info)
         cancel_delayed_work(&info->deferred_work);
         flush_scheduled_work();
 
-        /*  the list may have still some non-dirty pages at this point */
-        mutex_lock(&fbdefio->lock);
-        list_for_each_safe(node, tmp_node, &fbdefio->pagelist) {
-                list_del(node);
-        }
-        mutex_unlock(&fbdefio->lock);
-
         /* clear out the mapping that we setup */
         for (i = 0 ; i < info->fix.smem_len; i += PAGE_SIZE) {
                 page = fb_deferred_io_page(info, i);