4 files changed, 141 insertions, 43 deletions

diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 94b8d820c512..610d2cc02cf8 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -328,7 +328,7 @@ config ACPI_CONTAINER
 config ACPI_HOTPLUG_MEMORY
         tristate "Memory Hotplug"
         depends on ACPI
-        depends on MEMORY_HOTPLUG || X86_64
+        depends on MEMORY_HOTPLUG
         default n
         help
           This driver adds supports for ACPI Memory Hotplug.  This driver
diff --git a/drivers/acpi/acpi_memhotplug.c b/drivers/acpi/acpi_memhotplug.c
index e0a95ba72371..1012284ff4f7 100644
--- a/drivers/acpi/acpi_memhotplug.c
+++ b/drivers/acpi/acpi_memhotplug.c
@@ -57,6 +57,7 @@ MODULE_LICENSE("GPL");
 
 static int acpi_memory_device_add(struct acpi_device *device);
 static int acpi_memory_device_remove(struct acpi_device *device, int type);
+static int acpi_memory_device_start(struct acpi_device *device);
 
 static struct acpi_driver acpi_memory_device_driver = {
         .name = ACPI_MEMORY_DEVICE_DRIVER_NAME,
@@ -65,48 +66,79 @@ static struct acpi_driver acpi_memory_device_driver = {
         .ops = {
                 .add = acpi_memory_device_add,
                 .remove = acpi_memory_device_remove,
+                .start = acpi_memory_device_start,
                 },
 };
 
+struct acpi_memory_info {
+        struct list_head list;
+        u64 start_addr;         /* Memory Range start physical addr */
+        u64 length;             /* Memory Range length */
+        unsigned short caching; /* memory cache attribute */
+        unsigned short write_protect;   /* memory read/write attribute */
+        unsigned int enabled:1;
+};
+
 struct acpi_memory_device {
         acpi_handle handle;
         unsigned int state;     /* State of the memory device */
-        unsigned short caching; /* memory cache attribute */
-        unsigned short write_protect;   /* memory read/write attribute */
-        u64 start_addr;         /* Memory Range start physical addr */
-        u64 length;             /* Memory Range length */
+        struct list_head res_list;
 };
 
+static acpi_status
+acpi_memory_get_resource(struct acpi_resource *resource, void *context)
+{
+        struct acpi_memory_device *mem_device = context;
+        struct acpi_resource_address64 address64;
+        struct acpi_memory_info *info, *new;
+        acpi_status status;
+
+        status = acpi_resource_to_address64(resource, &address64);
+        if (ACPI_FAILURE(status) ||
+            (address64.resource_type != ACPI_MEMORY_RANGE))
+                return AE_OK;
+
+        list_for_each_entry(info, &mem_device->res_list, list) {
+                /* Can we combine the resource range information? */
+                if ((info->caching == address64.info.mem.caching) &&
+                    (info->write_protect == address64.info.mem.write_protect) &&
+                    (info->start_addr + info->length == address64.minimum)) {
+                        info->length += address64.address_length;
+                        return AE_OK;
+                }
+        }
+
+        new = kzalloc(sizeof(struct acpi_memory_info), GFP_KERNEL);
+        if (!new)
+                return AE_ERROR;
+
+        INIT_LIST_HEAD(&new->list);
+        new->caching = address64.info.mem.caching;
+        new->write_protect = address64.info.mem.write_protect;
+        new->start_addr = address64.minimum;
+        new->length = address64.address_length;
+        list_add_tail(&new->list, &mem_device->res_list);
+
+        return AE_OK;
+}
+
 static int
 acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
 {
         acpi_status status;
-        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
-        struct acpi_resource *resource = NULL;
-        struct acpi_resource_address64 address64;
+        struct acpi_memory_info *info, *n;
 
         ACPI_FUNCTION_TRACE("acpi_memory_get_device_resources");
 
-        /* Get the range from the _CRS */
-        status = acpi_get_current_resources(mem_device->handle, &buffer);
-        if (ACPI_FAILURE(status))
-                return_VALUE(-EINVAL);
-
-        resource = (struct acpi_resource *)buffer.pointer;
-        status = acpi_resource_to_address64(resource, &address64);
-        if (ACPI_SUCCESS(status)) {
-                if (address64.resource_type == ACPI_MEMORY_RANGE) {
-                        /* Populate the structure */
-                        mem_device->caching = address64.info.mem.caching;
-                        mem_device->write_protect =
-                            address64.info.mem.write_protect;
-                        mem_device->start_addr = address64.minimum;
-                        mem_device->length = address64.address_length;
-                }
+        status = acpi_walk_resources(mem_device->handle, METHOD_NAME__CRS,
+                                     acpi_memory_get_resource, mem_device);
+        if (ACPI_FAILURE(status)) {
+                list_for_each_entry_safe(info, n, &mem_device->res_list, list)
+                        kfree(info);
+                return -EINVAL;
         }
 
-        acpi_os_free(buffer.pointer);
-        return_VALUE(0);
+        return 0;
 }
 
 static int
@@ -181,7 +213,9 @@ static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
 
 static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
 {
-        int result;
+        int result, num_enabled = 0;
+        struct acpi_memory_info *info;
+        int node;
 
         ACPI_FUNCTION_TRACE("acpi_memory_enable_device");
 
@@ -194,15 +228,35 @@ static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
                 return result;
         }
 
+        node = acpi_get_node(mem_device->handle);
         /*
          * Tell the VM there is more memory here...
          * Note: Assume that this function returns zero on success
+         * We don't have memory-hot-add rollback function,now.
+         * (i.e. memory-hot-remove function)
          */
-        result = add_memory(mem_device->start_addr, mem_device->length);
-        if (result) {
+        list_for_each_entry(info, &mem_device->res_list, list) {
+                u64 start_pfn, end_pfn;
+
+                start_pfn = info->start_addr >> PAGE_SHIFT;
+                end_pfn = (info->start_addr + info->length - 1) >> PAGE_SHIFT;
+
+                if (pfn_valid(start_pfn) || pfn_valid(end_pfn)) {
+                        /* already enabled. try next area */
+                        num_enabled++;
+                        continue;
+                }
+
+                result = add_memory(node, info->start_addr, info->length);
+                if (result)
+                        continue;
+                info->enabled = 1;
+                num_enabled++;
+        }
+        if (!num_enabled) {
                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "\nadd_memory failed\n"));
                 mem_device->state = MEMORY_INVALID_STATE;
-                return result;
+                return -EINVAL;
         }
 
         return result;
@@ -246,8 +300,7 @@ static int acpi_memory_powerdown_device(struct acpi_memory_device *mem_device)
 static int acpi_memory_disable_device(struct acpi_memory_device *mem_device)
 {
         int result;
-        u64 start = mem_device->start_addr;
-        u64 len = mem_device->length;
+        struct acpi_memory_info *info, *n;
 
         ACPI_FUNCTION_TRACE("acpi_memory_disable_device");
 
@@ -255,10 +308,13 @@ static int acpi_memory_disable_device(struct acpi_memory_device *mem_device)
          * Ask the VM to offline this memory range.
          * Note: Assume that this function returns zero on success
          */
-        result = remove_memory(start, len);
-        if (result) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Hot-Remove failed.\n"));
-                return_VALUE(result);
+        list_for_each_entry_safe(info, n, &mem_device->res_list, list) {
+                if (info->enabled) {
+                        result = remove_memory(info->start_addr, info->length);
+                        if (result)
+                                return result;
+                }
+                kfree(info);
         }
 
         /* Power-off and eject the device */
@@ -356,6 +412,7 @@ static int acpi_memory_device_add(struct acpi_device *device)
                 return_VALUE(-ENOMEM);
         memset(mem_device, 0, sizeof(struct acpi_memory_device));
 
+        INIT_LIST_HEAD(&mem_device->res_list);
         mem_device->handle = device->handle;
         sprintf(acpi_device_name(device), "%s", ACPI_MEMORY_DEVICE_NAME);
         sprintf(acpi_device_class(device), "%s", ACPI_MEMORY_DEVICE_CLASS);
@@ -391,6 +448,25 @@ static int acpi_memory_device_remove(struct acpi_device *device, int type)
         return_VALUE(0);
 }
 
+static int acpi_memory_device_start (struct acpi_device *device)
+{
+        struct acpi_memory_device *mem_device;
+        int result = 0;
+
+        ACPI_FUNCTION_TRACE("acpi_memory_device_start");
+
+        mem_device = acpi_driver_data(device);
+
+        if (!acpi_memory_check_device(mem_device)) {
+                /* call add_memory func */
+                result = acpi_memory_enable_device(mem_device);
+                if (result)
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                "Error in acpi_memory_enable_device\n"));
+        }
+        return_VALUE(result);
+}
+
 /*
  * Helper function to check for memory device
  */
diff --git a/drivers/acpi/numa.c b/drivers/acpi/numa.c
index e2c1a16078c9..13d6d5bdea26 100644
--- a/drivers/acpi/numa.c
+++ b/drivers/acpi/numa.c
@@ -254,5 +254,18 @@ int acpi_get_pxm(acpi_handle h)
         } while (ACPI_SUCCESS(status));
         return -1;
 }
-
 EXPORT_SYMBOL(acpi_get_pxm);
+
+int acpi_get_node(acpi_handle *handle)
+{
+        int pxm, node = -1;
+
+        ACPI_FUNCTION_TRACE("acpi_get_node");
+
+        pxm = acpi_get_pxm(handle);
+        if (pxm >= 0)
+                node = acpi_map_pxm_to_node(pxm);
+
+        return_VALUE(node);
+}
+EXPORT_SYMBOL(acpi_get_node);
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index 3b97a5eae9e8..8a74bf3efd8e 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -206,11 +206,11 @@ acpi_processor_power_activate(struct acpi_processor *pr,
 
 static void acpi_safe_halt(void)
 {
-        clear_thread_flag(TIF_POLLING_NRFLAG);
+        current_thread_info()->status &= ~TS_POLLING;
         smp_mb__after_clear_bit();
         if (!need_resched())
                 safe_halt();
-        set_thread_flag(TIF_POLLING_NRFLAG);
+        current_thread_info()->status |= TS_POLLING;
 }
 
 static atomic_t c3_cpu_count;
@@ -330,10 +330,10 @@ static void acpi_processor_idle(void)
          * Invoke the current Cx state to put the processor to sleep.
          */
         if (cx->type == ACPI_STATE_C2 || cx->type == ACPI_STATE_C3) {
-                clear_thread_flag(TIF_POLLING_NRFLAG);
+                current_thread_info()->status &= ~TS_POLLING;
                 smp_mb__after_clear_bit();
                 if (need_resched()) {
-                        set_thread_flag(TIF_POLLING_NRFLAG);
+                        current_thread_info()->status |= TS_POLLING;
                         local_irq_enable();
                         return;
                 }
@@ -369,9 +369,14 @@ static void acpi_processor_idle(void)
                 t2 = inl(acpi_fadt.xpm_tmr_blk.address);
                 /* Get end time (ticks) */
                 t2 = inl(acpi_fadt.xpm_tmr_blk.address);
+
+#ifdef CONFIG_GENERIC_TIME
+                /* TSC halts in C2, so notify users */
+                mark_tsc_unstable();
+#endif
                 /* Re-enable interrupts */
                 local_irq_enable();
-                set_thread_flag(TIF_POLLING_NRFLAG);
+                current_thread_info()->status |= TS_POLLING;
                 /* Compute time (ticks) that we were actually asleep */
                 sleep_ticks =
                     ticks_elapsed(t1, t2) - cx->latency_ticks - C2_OVERHEAD;
@@ -409,9 +414,13 @@ static void acpi_processor_idle(void)
                                           ACPI_MTX_DO_NOT_LOCK);
                 }
 
+#ifdef CONFIG_GENERIC_TIME
+                /* TSC halts in C3, so notify users */
+                mark_tsc_unstable();
+#endif
                 /* Re-enable interrupts */
                 local_irq_enable();
-                set_thread_flag(TIF_POLLING_NRFLAG);
+                current_thread_info()->status |= TS_POLLING;
                 /* Compute time (ticks) that we were actually asleep */
                 sleep_ticks =
                     ticks_elapsed(t1, t2) - cx->latency_ticks - C3_OVERHEAD;