Release 4.10 drivers/acpi/acpi_memhotplug.c

Directory: drivers/acpi
/*
 * Copyright (C) 2004, 2013 Intel Corporation
 * Author: Naveen B S <naveen.b.s@intel.com>
 * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
 *
 * 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.
 *
 * ACPI based HotPlug driver that supports Memory Hotplug
 * This driver fields notifications from firmware for memory add
 * and remove operations and alerts the VM of the affected memory
 * ranges.
 */

#include <linux/acpi.h>
#include <linux/memory.h>
#include <linux/memory_hotplug.h>

#include "internal.h"


#define ACPI_MEMORY_DEVICE_CLASS		"memory"

#define ACPI_MEMORY_DEVICE_HID			"PNP0C80"

#define ACPI_MEMORY_DEVICE_NAME			"Hotplug Mem Device"


#define _COMPONENT		ACPI_MEMORY_DEVICE_COMPONENT


#undef PREFIX

#define 	PREFIX		"ACPI:memory_hp:"

ACPI_MODULE_NAME("acpi_memhotplug");


static const struct acpi_device_id memory_device_ids[] = {
	{ACPI_MEMORY_DEVICE_HID, 0},
	{"", 0},
};

#ifdef CONFIG_ACPI_HOTPLUG_MEMORY

/* 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,
				  const struct acpi_device_id *not_used);
static void acpi_memory_device_remove(struct acpi_device *device);


static struct acpi_scan_handler memory_device_handler = {
	.ids = memory_device_ids,
	.attach = acpi_memory_device_add,
	.detach = acpi_memory_device_remove,
	.hotplug = {
		.enabled = true,
        },
};


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 {
	
struct acpi_device * device;
	
unsigned int state;	/* State of the memory device */
	
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.address.minimum)) {
			info->length += address64.address.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.address.minimum;
	new->length = address64.address.address_length;
	list_add_tail(&new->list, &mem_device->res_list);

	return AE_OK;
}

Contributors
Person Tokens Prop Commits CommitProp
kamezawa hiroyuki kamezawa hiroyuki 142 62.83% 2 28.57%
len brown len brown 71 31.42% 1 14.29%
lv zheng lv zheng 8 3.54% 1 14.29%
bjorn helgaas bjorn helgaas 2 0.88% 1 14.29%
patrick mochel patrick mochel 2 0.88% 1 14.29%
robert moore robert moore 1 0.44% 1 14.29%
Total 226 100.00% 7 100.00%


static void

acpi_memory_free_device_resources(struct acpi_memory_device *mem_device)
{
	struct acpi_memory_info *info, *n;

	list_for_each_entry_safe(info, n, &mem_device->res_list, list)
		kfree(info);
	INIT_LIST_HEAD(&mem_device->res_list);
}

Contributors
Person Tokens Prop Commits CommitProp
wen congyang wen congyang 26 61.90% 1 50.00%
kamezawa hiroyuki kamezawa hiroyuki 16 38.10% 1 50.00%
Total 42 100.00% 2 100.00%


static int

acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
{
	acpi_status status;

	if (!list_empty(&mem_device->res_list))
		return 0;

	status = acpi_walk_resources(mem_device->device->handle, METHOD_NAME__CRS,
				     acpi_memory_get_resource, mem_device);
	if (ACPI_FAILURE(status)) {
		acpi_memory_free_device_resources(mem_device);
		return -EINVAL;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
kamezawa hiroyuki kamezawa hiroyuki 45 68.18% 2 33.33%
wen congyang wen congyang 14 21.21% 1 16.67%
patrick mochel patrick mochel 4 6.06% 2 33.33%
len brown len brown 3 4.55% 1 16.67%
Total 66 100.00% 6 100.00%



static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
{
	unsigned long long current_status;

	/* Get device present/absent information from the _STA */
	if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->device->handle,
					       METHOD_NAME__STA, NULL,
					       &current_status)))
		return -ENODEV;
	/*
         * Check for device status. Device should be
         * present/enabled/functioning.
         */
	if (!((current_status & ACPI_STA_DEVICE_PRESENT)
	      && (current_status & ACPI_STA_DEVICE_ENABLED)
	      && (current_status & ACPI_STA_DEVICE_FUNCTIONING)))
		return -ENODEV;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
len brown len brown 60 82.19% 1 16.67%
patrick mochel patrick mochel 8 10.96% 2 33.33%
bjorn helgaas bjorn helgaas 3 4.11% 1 16.67%
matthew wilcox matthew wilcox 1 1.37% 1 16.67%
zhang yanfei zhang yanfei 1 1.37% 1 16.67%
Total 73 100.00% 6 100.00%



static unsigned long acpi_meminfo_start_pfn(struct acpi_memory_info *info)
{
	return PFN_DOWN(info->start_addr);
}

Contributors
Person Tokens Prop Commits CommitProp
rafael j. wysocki rafael j. wysocki 20 100.00% 1 100.00%
Total 20 100.00% 1 100.00%



static unsigned long acpi_meminfo_end_pfn(struct acpi_memory_info *info)
{
	return PFN_UP(info->start_addr + info->length-1);
}

Contributors
Person Tokens Prop Commits CommitProp
rafael j. wysocki rafael j. wysocki 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static int acpi_bind_memblk(struct memory_block *mem, void *arg)
{
	return acpi_bind_one(&mem->dev, arg);
}

Contributors
Person Tokens Prop Commits CommitProp
rafael j. wysocki rafael j. wysocki 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static int acpi_bind_memory_blocks(struct acpi_memory_info *info,
				   struct acpi_device *adev)
{
	return walk_memory_range(acpi_meminfo_start_pfn(info),
				 acpi_meminfo_end_pfn(info), adev,
				 acpi_bind_memblk);
}

Contributors
Person Tokens Prop Commits CommitProp
rafael j. wysocki rafael j. wysocki 34 100.00% 2 100.00%
Total 34 100.00% 2 100.00%



static int acpi_unbind_memblk(struct memory_block *mem, void *arg)
{
	acpi_unbind_one(&mem->dev);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
rafael j. wysocki rafael j. wysocki 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static void acpi_unbind_memory_blocks(struct acpi_memory_info *info)
{
	walk_memory_range(acpi_meminfo_start_pfn(info),
			  acpi_meminfo_end_pfn(info), NULL, acpi_unbind_memblk);
}

Contributors
Person Tokens Prop Commits CommitProp
rafael j. wysocki rafael j. wysocki 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%



static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
{
	acpi_handle handle = mem_device->device->handle;
	int result, num_enabled = 0;
	struct acpi_memory_info *info;
	int node;

	node = acpi_get_node(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)
         */
	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 the memory block has been used by the kernel, add_memory()
                 * returns -EEXIST. If add_memory() returns the other error, it
                 * means that this memory block is not used by the kernel.
                 */
		if (result && result != -EEXIST)
			continue;

		result = acpi_bind_memory_blocks(info, mem_device->device);
		if (result) {
			acpi_unbind_memory_blocks(info);
			return -ENODEV;
		}

		info->enabled = 1;

		/*
                 * Add num_enable even if add_memory() returns -EEXIST, so the
                 * device is bound to this driver.
                 */
		num_enabled++;
	}
	if (!num_enabled) {
		dev_err(&mem_device->device->dev, "add_memory failed\n");
		mem_device->state = MEMORY_INVALID_STATE;
		return -EINVAL;
	}
	/*
         * 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;
}

Contributors
Person Tokens Prop Commits CommitProp
kamezawa hiroyuki kamezawa hiroyuki 43 23.24% 2 14.29%
len brown len brown 43 23.24% 1 7.14%
rafael j. wysocki rafael j. wysocki 35 18.92% 2 14.29%
yasunori goto yasunori goto 20 10.81% 3 21.43%
keith mannthey keith mannthey 15 8.11% 1 7.14%
yakui zhao yakui zhao 11 5.95% 1 7.14%
toshi kani toshi kani 9 4.86% 1 7.14%
wen congyang wen congyang 7 3.78% 1 7.14%
andrew morton andrew morton 1 0.54% 1 7.14%
bjorn helgaas bjorn helgaas 1 0.54% 1 7.14%
Total 185 100.00% 14 100.00%



static void acpi_memory_remove_memory(struct acpi_memory_device *mem_device)
{
	acpi_handle handle = mem_device->device->handle;
	struct acpi_memory_info *info, *n;
	int nid = acpi_get_node(handle);

	list_for_each_entry_safe(info, n, &mem_device->res_list, list) {
		if (!info->enabled)
			continue;

		if (nid == NUMA_NO_NODE)
			nid = memory_add_physaddr_to_nid(info->start_addr);

		acpi_unbind_memory_blocks(info);
		remove_memory(nid, info->start_addr, info->length);
		list_del(&info->list);
		kfree(info);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
kamezawa hiroyuki kamezawa hiroyuki 31 30.39% 1 11.11%
tang chen tang chen 20 19.61% 1 11.11%
rafael j. wysocki rafael j. wysocki 18 17.65% 2 22.22%
len brown len brown 17 16.67% 1 11.11%
yasuaki ishimatsu yasuaki ishimatsu 11 10.78% 2 22.22%
wen congyang wen congyang 3 2.94% 1 11.11%
jianguo wu jianguo wu 2 1.96% 1 11.11%
Total 102 100.00% 9 100.00%



static void acpi_memory_device_free(struct acpi_memory_device *mem_device)
{
	if (!mem_device)
		return;

	acpi_memory_free_device_resources(mem_device);
	mem_device->device->driver_data = NULL;
	kfree(mem_device);
}

Contributors
Person Tokens Prop Commits CommitProp
len brown len brown 15 42.86% 1 20.00%
rafael j. wysocki rafael j. wysocki 14 40.00% 1 20.00%
wen congyang wen congyang 3 8.57% 1 20.00%
toshi kani toshi kani 3 8.57% 2 40.00%
Total 35 100.00% 5 100.00%



static int acpi_memory_device_add(struct acpi_device *device,
				  const struct acpi_device_id *not_used)
{
	struct acpi_memory_device *mem_device;
	int result;

	if (!device)
		return -EINVAL;

	mem_device = kzalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
	if (!mem_device)
		return -ENOMEM;

	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);
	device->driver_data = mem_device;

	/* Get the range from the _CRS */
	result = acpi_memory_get_device_resources(mem_device);
	if (result) {
		device->driver_data = NULL;
		kfree(mem_device);
		return result;
	}

	/* Set the device state */
	mem_device->state = MEMORY_POWER_ON_STATE;

	result = acpi_memory_check_device(mem_device);
	if (result) {
		acpi_memory_device_free(mem_device);
		return 0;
	}

	result = acpi_memory_enable_device(mem_device);
	if (result) {
		dev_err(&device->dev, "acpi_memory_enable_device() error\n");
		acpi_memory_device_free(mem_device);
		return result;
	}

	dev_dbg(&device->dev, "Memory device configured by ACPI\n");
	return 1;
}

Contributors
Person Tokens Prop Commits CommitProp
len brown len brown 105 52.50% 1 8.33%
rafael j. wysocki rafael j. wysocki 37 18.50% 2 16.67%
bjorn helgaas bjorn helgaas 18 9.00% 1 8.33%
toshi kani toshi kani 13 6.50% 2 16.67%
patrick mochel patrick mochel 9 4.50% 2 16.67%
kamezawa hiroyuki kamezawa hiroyuki 8 4.00% 1 8.33%
wen congyang wen congyang 7 3.50% 1 8.33%
pavel machek pavel machek 2 1.00% 1 8.33%
burman yan burman yan 1 0.50% 1 8.33%
Total 200 100.00% 12 100.00%



static void acpi_memory_device_remove(struct acpi_device *device)
{
	struct acpi_memory_device *mem_device;

	if (!device || !acpi_driver_data(device))
		return;

	mem_device = acpi_driver_data(device);
	acpi_memory_remove_memory(mem_device);
	acpi_memory_device_free(mem_device);
}

Contributors
Person Tokens Prop Commits CommitProp
len brown len brown 36 80.00% 1 25.00%
yasuaki ishimatsu yasuaki ishimatsu 6 13.33% 1 25.00%
rafael j. wysocki rafael j. wysocki 2 4.44% 1 25.00%
wen congyang wen congyang 1 2.22% 1 25.00%
Total 45 100.00% 4 100.00%


static bool __initdata acpi_no_memhotplug;



void __init acpi_memory_hotplug_init(void)
{
	if (acpi_no_memhotplug) {
		memory_device_handler.attach = NULL;
		acpi_scan_add_handler(&memory_device_handler);
		return;
	}
	acpi_scan_add_handler_with_hotplug(&memory_device_handler, "memory");
}

Contributors
Person Tokens Prop Commits CommitProp
rafael j. wysocki rafael j. wysocki 22 62.86% 2 50.00%
len brown len brown 8 22.86% 1 25.00%
prarit bhargava prarit bhargava 5 14.29% 1 25.00%
Total 35 100.00% 4 100.00%



static int __init disable_acpi_memory_hotplug(char *str)
{
	acpi_no_memhotplug = true;
	return 1;
}
Contributors
Person Tokens Prop Commits CommitProp
prarit bhargava prarit bhargava 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%

__setup("acpi_no_memhotplug", disable_acpi_memory_hotplug);

#else


static struct acpi_scan_handler memory_device_handler = {
	.ids = memory_device_ids,
};



void __init acpi_memory_hotplug_init(void)
{
	acpi_scan_add_handler(&memory_device_handler);
}

Contributors
Person Tokens Prop Commits CommitProp
rafael j. wysocki rafael j. wysocki 14 100.00% 1 100.00%
Total 14 100.00% 1 100.00%

#endif /* CONFIG_ACPI_HOTPLUG_MEMORY */
Overall Contributors
Person Tokens Prop Commits CommitProp
len brown len brown 454 32.02% 2 4.76%
rafael j. wysocki rafael j. wysocki 367 25.88% 5 11.90%
kamezawa hiroyuki kamezawa hiroyuki 317 22.36% 4 9.52%
wen congyang wen congyang 61 4.30% 3 7.14%
prarit bhargava prarit bhargava 35 2.47% 1 2.38%
patrick mochel patrick mochel 27 1.90% 3 7.14%
toshi kani toshi kani 25 1.76% 3 7.14%
bjorn helgaas bjorn helgaas 24 1.69% 3 7.14%
tang chen tang chen 20 1.41% 1 2.38%
yasunori goto yasunori goto 20 1.41% 3 7.14%
yakui zhao yakui zhao 18 1.27% 2 4.76%
yasuaki ishimatsu yasuaki ishimatsu 17 1.20% 2 4.76%
keith mannthey keith mannthey 15 1.06% 1 2.38%
lv zheng lv zheng 8 0.56% 1 2.38%
pavel machek pavel machek 2 0.14% 1 2.38%
jianguo wu jianguo wu 2 0.14% 1 2.38%
burman yan burman yan 1 0.07% 1 2.38%
andrew morton andrew morton 1 0.07% 1 2.38%
matthew wilcox matthew wilcox 1 0.07% 1 2.38%
robert moore robert moore 1 0.07% 1 2.38%
jarkko nikula jarkko nikula 1 0.07% 1 2.38%
zhang yanfei zhang yanfei 1 0.07% 1 2.38%
Total 1418 100.00% 42 100.00%
Directory: drivers/acpi

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
kamezawa hiroyuki	kamezawa hiroyuki	142	62.83%	2	28.57%
len brown	len brown	71	31.42%	1	14.29%
lv zheng	lv zheng	8	3.54%	1	14.29%
bjorn helgaas	bjorn helgaas	2	0.88%	1	14.29%
patrick mochel	patrick mochel	2	0.88%	1	14.29%
robert moore	robert moore	1	0.44%	1	14.29%
	Total	226	100.00%	7	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 drivers/acpi/acpi_memhotplug.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
