public inbox for linux-acpi@vger.kernel.org
 help / color / mirror / Atom feed
* RE: [PATCH] /sys/firmware/acpi/memory/ for showing info of ACPI memory object
@ 2004-09-16 14:07 Tolentino, Matthew E
       [not found] ` <D36CE1FCEFD3524B81CA12C6FE5BCAB007B6FA60-oCDej+MBycNZtRGVdHMbwrfspsVTdybXVpNB7YpNyf8@public.gmane.org>
  0 siblings, 1 reply; 7+ messages in thread
From: Tolentino, Matthew E @ 2004-09-16 14:07 UTC (permalink / raw)
  To: Keiichiro Tokunaga, S, Naveen B, Dave Hansen
  Cc: acpi-devel-5NWGOfrQmneRv+LV9MX5uipxlwaOVQ5f,
	lhms-devel-5NWGOfrQmneRv+LV9MX5uipxlwaOVQ5f

>I have changed the patch to create directories and files in
>/sys/firmware/acpi/memory/ from Dave's comments.  The files are
>to export the following stuffs of each ACPI memory object for the
>first version.

Hmm.  I thought Dave's suggestion was to create an arch-agnostic
viewpoint of physical memory and dump it into 
/sys/devices/system/memory in order to gain consistency between
arches...  

># ls /sys/firmware/acpi/memory/MEM1/
>address_length
>address_translation_offset
>granularity
>max_address_fixed
>max_address_range
>min_address_fixed
>min_address_range
>producer_consumer
>resource_type

For my understanding, what exactly are all of these attributes for?

matt


-------------------------------------------------------
This SF.Net email is sponsored by: YOU BE THE JUDGE. Be one of 170
Project Admins to receive an Apple iPod Mini FREE for your judgement on
who ports your project to Linux PPC the best. Sponsored by IBM.
Deadline: Sept. 24. Go here: http://sf.net/ppc_contest.php

^ permalink raw reply	[flat|nested] 7+ messages in thread
* [PATCH] ACPI based Memory Hotplug Driver Patch
@ 2004-09-09 10:54 S, Naveen B
  2004-09-10 14:02 ` Keiichiro Tokunaga
  0 siblings, 1 reply; 7+ messages in thread
From: S, Naveen B @ 2004-09-09 10:54 UTC (permalink / raw)
  To: acpi-devel-5NWGOfrQmneRv+LV9MX5uipxlwaOVQ5f,
	lhms-devel-5NWGOfrQmneRv+LV9MX5uipxlwaOVQ5f
  Cc: Tolentino, Matthew E, S, Naveen B

Hi,

Attached is an ACPI based hot plug driver patch to support physical memory hotplug. This driver supports physical hotplug operation on memory, fields notifications from firmware and notifies the VM of the affected memory ranges.  The following patch is against kernel 2.6.8.1-mm3, and works with the current memory hotplug VM patches posted at: http://sprucegoose.sr71.net/patches.  This patch has been tested on real prototype hardware in the hot-add memory case. Hot remove feature is tested in an emulated environment (by overriding ACPI DSDT). 

Please review and consider for inclusion. 

Thanks & Regards


Signed-off-by: Naveen B S <naveen.b.s-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org>
Signed-off-by: Matt Tolentino <matthew.e.tolentino-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org>

 drivers/acpi/Kconfig      |    7 
 drivers/acpi/Makefile     |    1 
 drivers/acpi/acpi_ksyms.c |    1 
 drivers/acpi/memory.c     |  576 ++++++++++++++++++++++++++++++++++++++++++++++
 drivers/acpi/scan.c       |    2 
 include/acpi/acpi_bus.h   |    2 
 6 files changed, 588 insertions(+), 1 deletion(-)


diff -Nura linux-2.6.8.1-mm3-orig/drivers/acpi/acpi_ksyms.c linux-2.6.8.1-mm3-hpmem/drivers/acpi/acpi_ksyms.c
--- linux-2.6.8.1-mm3-orig/drivers/acpi/acpi_ksyms.c	2004-09-09 13:55:36.000000000 +0530
+++ linux-2.6.8.1-mm3-hpmem/drivers/acpi/acpi_ksyms.c	2004-09-09 14:01:11.000000000 +0530
@@ -135,6 +135,7 @@
 EXPORT_SYMBOL(acpi_bus_receive_event);
 EXPORT_SYMBOL(acpi_bus_register_driver);
 EXPORT_SYMBOL(acpi_bus_unregister_driver);
+EXPORT_SYMBOL(acpi_bus_add);
 
 #endif /*CONFIG_ACPI_BUS*/
 
diff -Nura linux-2.6.8.1-mm3-orig/drivers/acpi/Kconfig linux-2.6.8.1-mm3-hpmem/drivers/acpi/Kconfig
--- linux-2.6.8.1-mm3-orig/drivers/acpi/Kconfig	2004-09-09 13:55:36.000000000 +0530
+++ linux-2.6.8.1-mm3-hpmem/drivers/acpi/Kconfig	2004-09-09 14:01:11.000000000 +0530
@@ -270,5 +270,12 @@
 	  kernel logs, and/or you are using this on a notebook which
 	  does not yet have an HPET, you should say "Y" here.
 
+config ACPI_HOTPLUG_MEMORY
+	tristate "Memory Hotplug"
+	depends on ACPI
+	depends on MEMORY_HOTPLUG
+	default m
+	help
+	  This driver adds supports for ACPI Memory Hotplug.
 endmenu
 
diff -Nura linux-2.6.8.1-mm3-orig/drivers/acpi/Makefile linux-2.6.8.1-mm3-hpmem/drivers/acpi/Makefile
--- linux-2.6.8.1-mm3-orig/drivers/acpi/Makefile	2004-09-09 13:55:36.000000000 +0530
+++ linux-2.6.8.1-mm3-hpmem/drivers/acpi/Makefile	2004-09-09 14:01:11.000000000 +0530
@@ -48,3 +48,4 @@
 obj-$(CONFIG_ACPI_ASUS)		+= asus_acpi.o
 obj-$(CONFIG_ACPI_TOSHIBA)	+= toshiba_acpi.o
 obj-$(CONFIG_ACPI_BUS)		+= scan.o motherboard.o
+obj-$(CONFIG_ACPI_HOTPLUG_MEMORY)	+= memory.o
diff -Nura linux-2.6.8.1-mm3-orig/drivers/acpi/memory.c linux-2.6.8.1-mm3-hpmem/drivers/acpi/memory.c
--- linux-2.6.8.1-mm3-orig/drivers/acpi/memory.c	1970-01-01 05:30:00.000000000 +0530
+++ linux-2.6.8.1-mm3-hpmem/drivers/acpi/memory.c	2004-09-09 14:01:47.000000000 +0530
@@ -0,0 +1,576 @@
+/*
+ * Copyright (C) 2004 Intel Corporation <naveen.b.s-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org>
+ *
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
+ * NON INFRINGEMENT.  See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ * ACPI based HotPlug driver that supports Memory Hotplug 
+ * This driver fields notifications from firmare for memory add
+ * and remove operations and alerts the VM of the affected memory
+ * ranges.  
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/memory_hotplug.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-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org>");
+MODULE_DESCRIPTION(ACPI_MEMORY_DEVICE_DRIVER_NAME);
+MODULE_LICENSE("GPL");
+
+/* ACPI _STA method values */
+#define ACPI_MEMORY_STA_PRESENT		(0x00000001UL)
+#define ACPI_MEMORY_STA_ENABLED		(0x00000002UL)
+#define ACPI_MEMORY_STA_FUNCTIONAL	(0x00000008UL)
+
+/* Memory Device States */
+#define MEMORY_INVALID_STATE	0
+#define MEMORY_POWER_ON_STATE	1
+#define MEMORY_POWER_OFF_STATE	2
+
+static int acpi_memory_device_add (struct acpi_device *device);
+static int acpi_memory_device_remove (struct acpi_device *device, int type);
+
+static struct acpi_driver acpi_memory_device_driver = {
+	.name =		ACPI_MEMORY_DEVICE_DRIVER_NAME,
+	.class =	ACPI_MEMORY_DEVICE_CLASS,
+	.ids =		ACPI_MEMORY_DEVICE_HID,
+	.ops =		{
+				.add =		acpi_memory_device_add,
+				.remove =	acpi_memory_device_remove,
+			},
+};
+
+struct acpi_memory_device {
+	acpi_handle handle;	
+	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 */
+};
+
+
+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_address16 *address16 = NULL;
+	struct acpi_resource_address32 *address32 = NULL;
+	struct acpi_resource_address64 *address64 = NULL;
+
+	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;
+		
+	switch (resource->id) {
+	case ACPI_RSTYPE_ADDRESS16:
+		address16 = (struct acpi_resource_address16 *) &resource->data;
+		if (address16->resource_type != ACPI_MEMORY_RANGE) 
+			break;
+
+		/* Populate the structure */
+		mem_device->cache_attribute = 
+			address16->attribute.memory.cache_attribute;
+		mem_device->read_write_attribute = 
+			address16->attribute.memory.read_write_attribute;
+		mem_device->start_addr = address16->min_address_range;
+		mem_device->end_addr = address16->max_address_range;
+		break;
+
+	case ACPI_RSTYPE_ADDRESS32:
+		address32 = (struct acpi_resource_address32 *) &resource->data;
+		if (address32->resource_type != ACPI_MEMORY_RANGE) 
+			break;
+		
+		/* Populate the structure */
+		mem_device->cache_attribute = 
+			address32->attribute.memory.cache_attribute;
+		mem_device->read_write_attribute = 
+			address32->attribute.memory.read_write_attribute;
+		mem_device->start_addr = address32->min_address_range;
+		mem_device->end_addr = address32->max_address_range;
+		break;
+		
+	case ACPI_RSTYPE_ADDRESS64:
+		address64 = (struct acpi_resource_address64 *) &resource->data;
+		if (address64->resource_type != ACPI_MEMORY_RANGE) 
+			break;
+
+		/* 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;
+		break;
+
+	default:
+		break;
+	}
+
+	acpi_os_free(buffer.pointer);
+	return_VALUE(0);
+}
+
+static int 
+acpi_memory_get_device(acpi_handle handle,
+	struct acpi_memory_device **mem_device) 
+{
+	acpi_status status;
+	acpi_handle phandle;
+	struct acpi_device *device = NULL;
+	struct acpi_device *pdevice = NULL;
+
+	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);
+	}
+
+	/* 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);
+	}
+	
+	/* 
+	 * 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);
+	}
+
+end:
+	*mem_device = acpi_driver_data(device);
+	if (!(*mem_device)) {
+		printk(KERN_ERR "\n driver data not found" );
+		return_VALUE(-ENODEV);
+	}
+
+	return_VALUE(0);
+}
+
+static int 
+acpi_memory_check_device(struct acpi_memory_device *mem_device)
+{
+	unsigned long current_status;
+
+	ACPI_FUNCTION_TRACE("acpi_memory_check_device");
+
+	/* Get device present/absent information from the _STA */
+	if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->handle, "_STA", 
+		NULL, &current_status)))
+		return_VALUE(-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);
+
+	return_VALUE(0);
+}
+
+static int 
+acpi_memory_enable_device(struct acpi_memory_device *mem_device)
+{
+	int result;
+	
+	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"));
+		mem_device->state = MEMORY_INVALID_STATE;		
+		return result;
+	}
+
+	/* 
+	 * Tell the VM there is more memory here...
+	 * Note: Assume that this function returns zero on success 
+	 */
+	result = add_memory(mem_device->start_addr, 
+			(mem_device->end_addr - mem_device->start_addr) + 1,
+			mem_device->read_write_attribute);
+	if (result) {
+		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 
+			"\nadd_memory failed\n"));
+		mem_device->state = MEMORY_INVALID_STATE;		
+		return result;
+	}
+
+	return result;
+}
+
+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;
+
+	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, 
+			"_EJ0", &arg_list, NULL);
+	/* Return on _EJ0 failure */
+	if (ACPI_FAILURE(status)) {
+		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,"_EJ0 failed.\n"));
+		return_VALUE(-ENODEV);		
+	}
+
+	/* Evalute _STA to check if the device is disabled */
+	status = acpi_evaluate_integer(mem_device->handle, "_STA", 
+		NULL, &current_status);
+	if (ACPI_FAILURE(status))
+		return_VALUE(-ENODEV);
+
+	/* Check for device status.  Device should be disabled */
+	if (current_status & ACPI_MEMORY_STA_ENABLED) 
+		return_VALUE(-EINVAL);
+
+	return_VALUE(0);
+}
+
+static int 
+acpi_memory_disable_device(struct acpi_memory_device *mem_device) 
+{
+	int result;
+
+	ACPI_FUNCTION_TRACE("acpi_memory_disable_device");
+
+	/* 
+	 * Ask the VM to offline this memory range.
+	 * Note: Assume that this function returns zero on success 
+	 */
+	if (remove_memory(mem_device->start_addr,
+		(mem_device->end_addr - mem_device->start_addr) + 1,
+		mem_device->read_write_attribute)) {
+		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Hot-Remove failed.\n"));
+		return_VALUE(-EINVAL);	
+	}
+
+	/* 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;
+	}
+	
+	mem_device->state = MEMORY_POWER_OFF_STATE;
+	return result;	
+}
+
+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:
+		ACPI_DEBUG_PRINT((ACPI_DB_INFO, 
+			"\nReceived BUS CHECK notification for device\n"));
+		/* Fall Through */
+	case ACPI_NOTIFY_DEVICE_CHECK:
+		if (event == ACPI_NOTIFY_DEVICE_CHECK)
+			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;
+		}
+		
+		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"));
+		}
+		break;
+	case ACPI_NOTIFY_EJECT_REQUEST:
+		ACPI_DEBUG_PRINT((ACPI_DB_INFO, 
+			"\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"));
+			break;
+		}
+		mem_device = acpi_driver_data(device);
+		if (!mem_device) {
+			ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 
+					"Driver Data is NULL\n"));
+			break;
+		}
+	
+		/*
+		 * Currently disabling memory device from kernel mode
+		 * TBD: Can also be disabled from user mode scripts
+		 * TBD: Can also be disabled by Callback registration 
+		 * 	with generic sysfs driver
+		 */	
+		if (acpi_memory_disable_device(mem_device))
+			ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 
+				"Error in acpi_memory_disable_device\n"));
+		/*
+		 * TBD: Invoke acpi_bus_remove to cleanup data structures
+		 */
+		break;
+	default:
+		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+			"Unsupported event [0x%x]\n", event));
+		break;
+	}
+
+	return_VOID;
+}
+
+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);
+
+	mem_device = kmalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
+	if (!mem_device)
+		return_VALUE(-ENOMEM);
+	memset(mem_device, 0, sizeof(struct acpi_memory_device));
+
+	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);
+	acpi_driver_data(device) = mem_device;
+
+	/* Get the range from the _CRS */
+	result = acpi_memory_get_device_resources(mem_device);
+	if (result) {
+		kfree(mem_device);
+		return_VALUE(result);
+	}
+		
+	/* Set the device state */
+	mem_device->state = MEMORY_POWER_ON_STATE;
+
+	printk(KERN_INFO "%s \n", acpi_device_name(device));
+
+	return_VALUE(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);
+	
+	mem_device = (struct acpi_memory_device *) acpi_driver_data(device);
+	kfree(mem_device);
+
+	return_VALUE(0);
+}
+
+/* 
+ * Helper function to check for memory device 
+ */
+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);
+	if (ACPI_FAILURE(status)) 
+		return_ACPI_STATUS(AE_ERROR);
+	
+	info = buffer.pointer;
+	if (!(info->valid & ACPI_VALID_HID)) {
+		acpi_os_free(buffer.pointer);
+		return_ACPI_STATUS(AE_ERROR);
+	}
+	
+	hardware_id = info->hardware_id.value;
+	if ((hardware_id == NULL) || 
+		(strcmp(hardware_id, ACPI_MEMORY_DEVICE_HID))) 
+		status = AE_ERROR;
+	
+	acpi_os_free(buffer.pointer);
+	return_ACPI_STATUS(status);	
+}
+
+static acpi_status
+acpi_memory_register_notify_handler (acpi_handle handle, 
+	u32 level, void *ctxt, void **retv)
+{
+	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 */
+	
+	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);	
+}
+
+static acpi_status
+acpi_memory_deregister_notify_handler (acpi_handle handle, 
+			       u32 level, void *ctxt, void **retv)
+{
+	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 */
+	
+	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);	
+}
+
+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);
+	
+	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 
+				ACPI_UINT32_MAX,
+				acpi_memory_register_notify_handler, 
+				NULL, NULL);
+
+	if (ACPI_FAILURE (status)) {
+		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "walk_namespace failed\n"));
+		acpi_bus_unregister_driver(&acpi_memory_device_driver);
+		return_VALUE(-ENODEV);
+        }
+
+	return_VALUE(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
+	 * handles. 
+	 */
+	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 
+			ACPI_UINT32_MAX,
+			acpi_memory_deregister_notify_handler, 
+			NULL, NULL);
+
+	if (ACPI_FAILURE (status)) 
+		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "walk_namespace failed\n"));
+
+	acpi_bus_unregister_driver(&acpi_memory_device_driver);
+
+	return_VOID;
+}
+
+module_init(acpi_memory_device_init);
+module_exit(acpi_memory_device_exit);
+
+
diff -Nura linux-2.6.8.1-mm3-orig/drivers/acpi/scan.c linux-2.6.8.1-mm3-hpmem/drivers/acpi/scan.c
--- linux-2.6.8.1-mm3-orig/drivers/acpi/scan.c	2004-09-09 13:55:36.000000000 +0530
+++ linux-2.6.8.1-mm3-hpmem/drivers/acpi/scan.c	2004-09-09 14:01:11.000000000 +0530
@@ -760,7 +760,7 @@
 #endif /*CONFIG_ACPI_DEBUG_OUTPUT*/
 }
 
-static int 
+int 
 acpi_bus_add (
 	struct acpi_device	**child,
 	struct acpi_device	*parent,
diff -Nura linux-2.6.8.1-mm3-orig/include/acpi/acpi_bus.h linux-2.6.8.1-mm3-hpmem/include/acpi/acpi_bus.h
--- linux-2.6.8.1-mm3-orig/include/acpi/acpi_bus.h	2004-09-09 13:55:01.000000000 +0530
+++ linux-2.6.8.1-mm3-hpmem/include/acpi/acpi_bus.h	2004-09-09 14:01:11.000000000 +0530
@@ -321,6 +321,8 @@
 int acpi_bus_receive_event (struct acpi_bus_event *event);
 int acpi_bus_register_driver (struct acpi_driver *driver);
 int acpi_bus_unregister_driver (struct acpi_driver *driver);
+int acpi_bus_add (struct acpi_device **child, struct acpi_device *parent,
+						acpi_handle handle, int type);
 
 int acpi_create_dir(struct acpi_device *);
 void acpi_remove_dir(struct acpi_device *);




-------------------------------------------------------
This SF.Net email is sponsored by BEA Weblogic Workshop
FREE Java Enterprise J2EE developer tools!
Get your free copy of BEA WebLogic Workshop 8.1 today.
http://ads.osdn.com/?ad_idP47&alloc_id\x10808&op=click

^ permalink raw reply	[flat|nested] 7+ messages in thread
end of thread, other threads:[~2004-09-24  8:46 UTC | newest]

Thread overview: 7+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2004-09-16 14:07 [PATCH] /sys/firmware/acpi/memory/ for showing info of ACPI memory object Tolentino, Matthew E
     [not found] ` <D36CE1FCEFD3524B81CA12C6FE5BCAB007B6FA60-oCDej+MBycNZtRGVdHMbwrfspsVTdybXVpNB7YpNyf8@public.gmane.org>
2004-09-16 16:00   ` Keiichiro Tokunaga
2004-09-16 16:46   ` Keiichiro Tokunaga
     [not found]     ` <20040917014611.000055db.tokunaga.keiich-+CUm20s59erQFUHtdCDX3A@public.gmane.org>
2004-09-16 17:55       ` Dave Hansen
2004-09-17  1:43         ` Keiichiro Tokunaga
  -- strict thread matches above, loose matches on Subject: below --
2004-09-09 10:54 [PATCH] ACPI based Memory Hotplug Driver Patch S, Naveen B
2004-09-10 14:02 ` Keiichiro Tokunaga
     [not found]   ` <20040910230200.73eb0374.tokunaga.keiich-+CUm20s59erQFUHtdCDX3A@public.gmane.org>
2004-09-16 10:47     ` [PATCH] /sys/firmware/acpi/memory/ for showing info of ACPI memory object Keiichiro Tokunaga
     [not found]       ` <20040916194725.562b50f0.tokunaga.keiich-+CUm20s59erQFUHtdCDX3A@public.gmane.org>
2004-09-24  8:46         ` Keiichiro Tokunaga

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox