include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[linux-2.6.git] / drivers / acpi / acpi_memhotplug.c
index 2143609..d985713 100644 (file)
@@ -20,7 +20,7 @@
  *
  *
  * ACPI based HotPlug driver that supports Memory Hotplug
- * This driver fields notifications from firmare for memory add
+ * This driver fields notifications from firmware for memory add
  * and remove operations and alerts the VM of the affected memory
  * ranges.
  */
 #include <linux/init.h>
 #include <linux/types.h>
 #include <linux/memory_hotplug.h>
+#include <linux/slab.h>
 #include <acpi/acpi_drivers.h>
 
-#define ACPI_MEMORY_DEVICE_COMPONENT           0x08000000UL
 #define ACPI_MEMORY_DEVICE_CLASS               "memory"
 #define ACPI_MEMORY_DEVICE_HID                 "PNP0C80"
-#define ACPI_MEMORY_DEVICE_DRIVER_NAME         "Hotplug Mem Driver"
 #define ACPI_MEMORY_DEVICE_NAME                        "Hotplug Mem Device"
 
 #define _COMPONENT             ACPI_MEMORY_DEVICE_COMPONENT
 
-ACPI_MODULE_NAME("acpi_memory")
-    MODULE_AUTHOR("Naveen B S <naveen.b.s@intel.com>");
-MODULE_DESCRIPTION(ACPI_MEMORY_DEVICE_DRIVER_NAME);
-MODULE_LICENSE("GPL");
+#undef PREFIX
+#define        PREFIX          "ACPI:memory_hp:"
 
-/* ACPI _STA method values */
-#define ACPI_MEMORY_STA_PRESENT                (0x00000001UL)
-#define ACPI_MEMORY_STA_ENABLED                (0x00000002UL)
-#define ACPI_MEMORY_STA_FUNCTIONAL     (0x00000008UL)
+ACPI_MODULE_NAME("acpi_memhotplug");
+MODULE_AUTHOR("Naveen B S <naveen.b.s@intel.com>");
+MODULE_DESCRIPTION("Hotplug Mem Driver");
+MODULE_LICENSE("GPL");
 
 /* Memory Device States */
 #define MEMORY_INVALID_STATE   0
@@ -58,56 +55,96 @@ 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 const struct acpi_device_id memory_device_ids[] = {
+       {ACPI_MEMORY_DEVICE_HID, 0},
+       {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, memory_device_ids);
+
 static struct acpi_driver acpi_memory_device_driver = {
-       .name = ACPI_MEMORY_DEVICE_DRIVER_NAME,
+       .name = "acpi_memhotplug",
        .class = ACPI_MEMORY_DEVICE_CLASS,
-       .ids = ACPI_MEMORY_DEVICE_HID,
+       .ids = memory_device_ids,
        .ops = {
                .add = acpi_memory_device_add,
                .remove = acpi_memory_device_remove,
                },
 };
 
+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;
+       struct acpi_device * device;
        unsigned int state;     /* State of the memory device */
-       unsigned short cache_attribute; /* memory cache attribute */
-       unsigned short read_write_attribute;    /* memory read/write attribute */
-       u64 start_addr;         /* Memory Range start physical addr */
-       u64 end_addr;           /* Memory Range end physical addr */
+       struct list_head res_list;
 };
 
+static int acpi_hotmem_initialized;
+
+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);
+       if (!list_empty(&mem_device->res_list))
+               return 0;
 
-       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->cache_attribute =
-                           address64.attribute.memory.cache_attribute;
-                       mem_device->read_write_attribute =
-                           address64.attribute.memory.read_write_attribute;
-                       mem_device->start_addr = address64.min_address_range;
-                       mem_device->end_addr = address64.max_address_range;
-               }
+       status = acpi_walk_resources(mem_device->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);
+               INIT_LIST_HEAD(&mem_device->res_list);
+               return -EINVAL;
        }
 
-       acpi_os_free(buffer.pointer);
-       return_VALUE(0);
+       return 0;
 }
 
 static int
@@ -118,96 +155,121 @@ acpi_memory_get_device(acpi_handle handle,
        acpi_handle phandle;
        struct acpi_device *device = NULL;
        struct acpi_device *pdevice = NULL;
+       int result;
 
-       ACPI_FUNCTION_TRACE("acpi_memory_get_device");
 
        if (!acpi_bus_get_device(handle, &device) && device)
                goto end;
 
        status = acpi_get_parent(handle, &phandle);
        if (ACPI_FAILURE(status)) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error in acpi_get_parent\n"));
-               return_VALUE(-EINVAL);
+               ACPI_EXCEPTION((AE_INFO, status, "Cannot find acpi parent"));
+               return -EINVAL;
        }
 
        /* Get the parent device */
-       status = acpi_bus_get_device(phandle, &pdevice);
-       if (ACPI_FAILURE(status)) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                 "Error in acpi_bus_get_device\n"));
-               return_VALUE(-EINVAL);
+       result = acpi_bus_get_device(phandle, &pdevice);
+       if (result) {
+               printk(KERN_WARNING PREFIX "Cannot get acpi bus device");
+               return -EINVAL;
        }
 
        /*
         * Now add the notified device.  This creates the acpi_device
         * and invokes .add function
         */
-       status = acpi_bus_add(&device, pdevice, handle, ACPI_BUS_TYPE_DEVICE);
-       if (ACPI_FAILURE(status)) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error in acpi_bus_add\n"));
-               return_VALUE(-EINVAL);
+       result = acpi_bus_add(&device, pdevice, handle, ACPI_BUS_TYPE_DEVICE);
+       if (result) {
+               printk(KERN_WARNING PREFIX "Cannot add acpi bus");
+               return -EINVAL;
        }
 
       end:
        *mem_device = acpi_driver_data(device);
        if (!(*mem_device)) {
                printk(KERN_ERR "\n driver data not found");
-               return_VALUE(-ENODEV);
+               return -ENODEV;
        }
 
-       return_VALUE(0);
+       return 0;
 }
 
 static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
 {
-       unsigned long current_status;
-
-       ACPI_FUNCTION_TRACE("acpi_memory_check_device");
+       unsigned long long current_status;
 
        /* Get device present/absent information from the _STA */
-       if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->handle, "_STA",
+       if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->device->handle, "_STA",
                                               NULL, &current_status)))
-               return_VALUE(-ENODEV);
+               return -ENODEV;
        /*
         * Check for device status. Device should be
         * present/enabled/functioning.
         */
-       if (!((current_status & ACPI_MEMORY_STA_PRESENT)
-             && (current_status & ACPI_MEMORY_STA_ENABLED)
-             && (current_status & ACPI_MEMORY_STA_FUNCTIONAL)))
-               return_VALUE(-ENODEV);
+       if (!((current_status & ACPI_STA_DEVICE_PRESENT)
+             && (current_status & ACPI_STA_DEVICE_ENABLED)
+             && (current_status & ACPI_STA_DEVICE_FUNCTIONING)))
+               return -ENODEV;
 
-       return_VALUE(0);
+       return 0;
 }
 
 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");
 
        /* Get the range from the _CRS */
        result = acpi_memory_get_device_resources(mem_device);
        if (result) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                 "\nget_device_resources failed\n"));
+               printk(KERN_ERR PREFIX "get_device_resources failed\n");
                mem_device->state = MEMORY_INVALID_STATE;
                return result;
        }
 
+       node = acpi_get_node(mem_device->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->end_addr - mem_device->start_addr) + 1);
-       if (result) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "\nadd_memory failed\n"));
+       list_for_each_entry(info, &mem_device->res_list, list) {
+               if (info->enabled) { /* just sanity check...*/
+                       num_enabled++;
+                       continue;
+               }
+               /*
+                * If the memory block size is zero, please ignore it.
+                * Don't try to do the following memory hotplug flowchart.
+                */
+               if (!info->length)
+                       continue;
+               if (node < 0)
+                       node = memory_add_physaddr_to_nid(info->start_addr);
+
+               result = add_memory(node, info->start_addr, info->length);
+               if (result)
+                       continue;
+               info->enabled = 1;
+               num_enabled++;
+       }
+       if (!num_enabled) {
+               printk(KERN_ERR PREFIX "add_memory failed\n");
                mem_device->state = MEMORY_INVALID_STATE;
-               return result;
+               return -EINVAL;
        }
-
-       return result;
+       /*
+        * Sometimes the memory device will contain several memory blocks.
+        * When one memory block is hot-added to the system memory, it will
+        * be regarded as a success.
+        * Otherwise if the last memory block can't be hot-added to the system
+        * memory, it will be failure and the memory device can't be bound with
+        * driver.
+        */
+       return 0;
 }
 
 static int acpi_memory_powerdown_device(struct acpi_memory_device *mem_device)
@@ -215,60 +277,57 @@ static int acpi_memory_powerdown_device(struct acpi_memory_device *mem_device)
        acpi_status status;
        struct acpi_object_list arg_list;
        union acpi_object arg;
-       unsigned long current_status;
+       unsigned long long current_status;
 
-       ACPI_FUNCTION_TRACE("acpi_memory_powerdown_device");
 
        /* Issue the _EJ0 command */
        arg_list.count = 1;
        arg_list.pointer = &arg;
        arg.type = ACPI_TYPE_INTEGER;
        arg.integer.value = 1;
-       status = acpi_evaluate_object(mem_device->handle,
+       status = acpi_evaluate_object(mem_device->device->handle,
                                      "_EJ0", &arg_list, NULL);
        /* Return on _EJ0 failure */
        if (ACPI_FAILURE(status)) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "_EJ0 failed.\n"));
-               return_VALUE(-ENODEV);
+               ACPI_EXCEPTION((AE_INFO, status, "_EJ0 failed"));
+               return -ENODEV;
        }
 
        /* Evalute _STA to check if the device is disabled */
-       status = acpi_evaluate_integer(mem_device->handle, "_STA",
+       status = acpi_evaluate_integer(mem_device->device->handle, "_STA",
                                       NULL, &current_status);
        if (ACPI_FAILURE(status))
-               return_VALUE(-ENODEV);
+               return -ENODEV;
 
        /* Check for device status.  Device should be disabled */
-       if (current_status & ACPI_MEMORY_STA_ENABLED)
-               return_VALUE(-EINVAL);
+       if (current_status & ACPI_STA_DEVICE_ENABLED)
+               return -EINVAL;
 
-       return_VALUE(0);
+       return 0;
 }
 
 static int acpi_memory_disable_device(struct acpi_memory_device *mem_device)
 {
        int result;
-       u64 start = mem_device->start_addr;
-       u64 len = mem_device->end_addr - start + 1;
-       unsigned long attr = mem_device->read_write_attribute;
+       struct acpi_memory_info *info, *n;
 
-       ACPI_FUNCTION_TRACE("acpi_memory_disable_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 */
        result = acpi_memory_powerdown_device(mem_device);
        if (result) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                 "Device Power Down failed.\n"));
                /* Set the status of the device to invalid */
                mem_device->state = MEMORY_INVALID_STATE;
                return result;
@@ -283,7 +342,6 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
        struct acpi_memory_device *mem_device;
        struct acpi_device *device;
 
-       ACPI_FUNCTION_TRACE("acpi_memory_device_notify");
 
        switch (event) {
        case ACPI_NOTIFY_BUS_CHECK:
@@ -295,15 +353,14 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
                        ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                          "\nReceived DEVICE CHECK notification for device\n"));
                if (acpi_memory_get_device(handle, &mem_device)) {
-                       ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                         "Error in finding driver data\n"));
-                       return_VOID;
+                       printk(KERN_ERR PREFIX "Cannot find driver data\n");
+                       return;
                }
 
                if (!acpi_memory_check_device(mem_device)) {
                        if (acpi_memory_enable_device(mem_device))
-                               ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                                 "Error in acpi_memory_enable_device\n"));
+                               printk(KERN_ERR PREFIX
+                                           "Cannot enable memory device\n");
                }
                break;
        case ACPI_NOTIFY_EJECT_REQUEST:
@@ -311,14 +368,12 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
                                  "\nReceived EJECT REQUEST notification for device\n"));
 
                if (acpi_bus_get_device(handle, &device)) {
-                       ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                         "Device doesn't exist\n"));
+                       printk(KERN_ERR PREFIX "Device doesn't exist\n");
                        break;
                }
                mem_device = acpi_driver_data(device);
                if (!mem_device) {
-                       ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                         "Driver Data is NULL\n"));
+                       printk(KERN_ERR PREFIX "Driver Data is NULL\n");
                        break;
                }
 
@@ -329,8 +384,8 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
                 *      with generic sysfs driver
                 */
                if (acpi_memory_disable_device(mem_device))
-                       ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                         "Error in acpi_memory_disable_device\n"));
+                       printk(KERN_ERR PREFIX
+                                   "Disable memory device\n");
                /*
                 * TBD: Invoke acpi_bus_remove to cleanup data structures
                 */
@@ -341,7 +396,7 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
                break;
        }
 
-       return_VOID;
+       return;
 }
 
 static int acpi_memory_device_add(struct acpi_device *device)
@@ -349,49 +404,63 @@ static int acpi_memory_device_add(struct acpi_device *device)
        int result;
        struct acpi_memory_device *mem_device = NULL;
 
-       ACPI_FUNCTION_TRACE("acpi_memory_device_add");
 
        if (!device)
-               return_VALUE(-EINVAL);
+               return -EINVAL;
 
-       mem_device = kmalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
+       mem_device = kzalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
        if (!mem_device)
-               return_VALUE(-ENOMEM);
-       memset(mem_device, 0, sizeof(struct acpi_memory_device));
+               return -ENOMEM;
 
-       mem_device->handle = device->handle;
+       INIT_LIST_HEAD(&mem_device->res_list);
+       mem_device->device = device;
        sprintf(acpi_device_name(device), "%s", ACPI_MEMORY_DEVICE_NAME);
        sprintf(acpi_device_class(device), "%s", ACPI_MEMORY_DEVICE_CLASS);
-       acpi_driver_data(device) = mem_device;
+       device->driver_data = mem_device;
 
        /* Get the range from the _CRS */
        result = acpi_memory_get_device_resources(mem_device);
        if (result) {
                kfree(mem_device);
-               return_VALUE(result);
+               return result;
        }
 
        /* Set the device state */
        mem_device->state = MEMORY_POWER_ON_STATE;
 
-       printk(KERN_INFO "%s \n", acpi_device_name(device));
+       printk(KERN_DEBUG "%s \n", acpi_device_name(device));
 
-       return_VALUE(result);
+       /*
+        * Early boot code has recognized memory area by EFI/E820.
+        * If DSDT shows these memory devices on boot, hotplug is not necessary
+        * for them. So, it just returns until completion of this driver's
+        * start up.
+        */
+       if (!acpi_hotmem_initialized)
+               return 0;
+
+       if (!acpi_memory_check_device(mem_device)) {
+               /* call add_memory func */
+               result = acpi_memory_enable_device(mem_device);
+               if (result)
+                       printk(KERN_ERR PREFIX
+                               "Error in acpi_memory_enable_device\n");
+       }
+       return result;
 }
 
 static int acpi_memory_device_remove(struct acpi_device *device, int type)
 {
        struct acpi_memory_device *mem_device = NULL;
 
-       ACPI_FUNCTION_TRACE("acpi_memory_device_remove");
 
        if (!device || !acpi_driver_data(device))
-               return_VALUE(-EINVAL);
+               return -EINVAL;
 
-       mem_device = (struct acpi_memory_device *)acpi_driver_data(device);
+       mem_device = acpi_driver_data(device);
        kfree(mem_device);
 
-       return_VALUE(0);
+       return 0;
 }
 
 /*
@@ -401,28 +470,24 @@ static acpi_status is_memory_device(acpi_handle handle)
 {
        char *hardware_id;
        acpi_status status;
-       struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
        struct acpi_device_info *info;
 
-       ACPI_FUNCTION_TRACE("is_memory_device");
-
-       status = acpi_get_object_info(handle, &buffer);
+       status = acpi_get_object_info(handle, &info);
        if (ACPI_FAILURE(status))
-               return_ACPI_STATUS(AE_ERROR);
+               return status;
 
-       info = buffer.pointer;
        if (!(info->valid & ACPI_VALID_HID)) {
-               acpi_os_free(buffer.pointer);
-               return_ACPI_STATUS(AE_ERROR);
+               kfree(info);
+               return AE_ERROR;
        }
 
-       hardware_id = info->hardware_id.value;
+       hardware_id = info->hardware_id.string;
        if ((hardware_id == NULL) ||
            (strcmp(hardware_id, ACPI_MEMORY_DEVICE_HID)))
                status = AE_ERROR;
 
-       acpi_os_free(buffer.pointer);
-       return_ACPI_STATUS(status);
+       kfree(info);
+       return status;
 }
 
 static acpi_status
@@ -431,21 +496,15 @@ acpi_memory_register_notify_handler(acpi_handle handle,
 {
        acpi_status status;
 
-       ACPI_FUNCTION_TRACE("acpi_memory_register_notify_handler");
 
        status = is_memory_device(handle);
        if (ACPI_FAILURE(status))
-               return_ACPI_STATUS(AE_OK);      /* continue */
+               return AE_OK;   /* continue */
 
        status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
                                             acpi_memory_device_notify, NULL);
-       if (ACPI_FAILURE(status)) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                 "Error installing notify handler\n"));
-               return_ACPI_STATUS(AE_OK);      /* continue */
-       }
-
-       return_ACPI_STATUS(status);
+       /* continue */
+       return AE_OK;
 }
 
 static acpi_status
@@ -454,22 +513,16 @@ acpi_memory_deregister_notify_handler(acpi_handle handle,
 {
        acpi_status status;
 
-       ACPI_FUNCTION_TRACE("acpi_memory_deregister_notify_handler");
 
        status = is_memory_device(handle);
        if (ACPI_FAILURE(status))
-               return_ACPI_STATUS(AE_OK);      /* continue */
+               return AE_OK;   /* continue */
 
        status = acpi_remove_notify_handler(handle,
                                            ACPI_SYSTEM_NOTIFY,
                                            acpi_memory_device_notify);
-       if (ACPI_FAILURE(status)) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                 "Error removing notify handler\n"));
-               return_ACPI_STATUS(AE_OK);      /* continue */
-       }
 
-       return_ACPI_STATUS(status);
+       return AE_OK;   /* continue */
 }
 
 static int __init acpi_memory_device_init(void)
@@ -477,32 +530,31 @@ static int __init acpi_memory_device_init(void)
        int result;
        acpi_status status;
 
-       ACPI_FUNCTION_TRACE("acpi_memory_device_init");
 
        result = acpi_bus_register_driver(&acpi_memory_device_driver);
 
        if (result < 0)
-               return_VALUE(-ENODEV);
+               return -ENODEV;
 
        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
                                     ACPI_UINT32_MAX,
-                                    acpi_memory_register_notify_handler,
+                                    acpi_memory_register_notify_handler, NULL,
                                     NULL, NULL);
 
        if (ACPI_FAILURE(status)) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "walk_namespace failed\n"));
+               ACPI_EXCEPTION((AE_INFO, status, "walk_namespace failed"));
                acpi_bus_unregister_driver(&acpi_memory_device_driver);
-               return_VALUE(-ENODEV);
+               return -ENODEV;
        }
 
-       return_VALUE(0);
+       acpi_hotmem_initialized = 1;
+       return 0;
 }
 
 static void __exit acpi_memory_device_exit(void)
 {
        acpi_status status;
 
-       ACPI_FUNCTION_TRACE("acpi_memory_device_exit");
 
        /*
         * Adding this to un-install notification handlers for all the device
@@ -510,15 +562,15 @@ static void __exit acpi_memory_device_exit(void)
         */
        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
                                     ACPI_UINT32_MAX,
-                                    acpi_memory_deregister_notify_handler,
+                                    acpi_memory_deregister_notify_handler, NULL,
                                     NULL, NULL);
 
        if (ACPI_FAILURE(status))
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "walk_namespace failed\n"));
+               ACPI_EXCEPTION((AE_INFO, status, "walk_namespace failed"));
 
        acpi_bus_unregister_driver(&acpi_memory_device_driver);
 
-       return_VOID;
+       return;
 }
 
 module_init(acpi_memory_device_init);