2008-04-19 04:33:50 +08:00
|
|
|
/*
|
|
|
|
* pseries Memory Hotplug infrastructure.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2008 Badari Pulavarty, IBM Corporation
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/of.h>
|
2010-07-12 12:36:09 +08:00
|
|
|
#include <linux/memblock.h>
|
2010-04-06 23:03:40 +08:00
|
|
|
#include <linux/vmalloc.h>
|
2011-06-14 08:57:51 +08:00
|
|
|
#include <linux/memory.h>
|
|
|
|
|
2008-04-19 04:33:50 +08:00
|
|
|
#include <asm/firmware.h>
|
|
|
|
#include <asm/machdep.h>
|
|
|
|
#include <asm/pSeries_reconfig.h>
|
2009-02-08 22:49:39 +08:00
|
|
|
#include <asm/sparsemem.h>
|
2008-04-19 04:33:50 +08:00
|
|
|
|
2011-01-21 00:45:20 +08:00
|
|
|
static unsigned long get_memblock_size(void)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
2011-06-14 08:57:51 +08:00
|
|
|
unsigned int memblock_size = MIN_MEMORY_BLOCK_SIZE;
|
|
|
|
struct resource r;
|
2011-01-21 00:45:20 +08:00
|
|
|
|
|
|
|
np = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory");
|
|
|
|
if (np) {
|
2011-06-14 08:57:51 +08:00
|
|
|
const __be64 *size;
|
2011-01-21 00:45:20 +08:00
|
|
|
|
|
|
|
size = of_get_property(np, "ibm,lmb-size", NULL);
|
2011-06-14 08:57:51 +08:00
|
|
|
if (size)
|
|
|
|
memblock_size = be64_to_cpup(size);
|
2011-01-21 00:45:20 +08:00
|
|
|
of_node_put(np);
|
2011-06-14 08:57:51 +08:00
|
|
|
} else if (machine_is(pseries)) {
|
|
|
|
/* This fallback really only applies to pseries */
|
2011-01-21 00:45:20 +08:00
|
|
|
unsigned int memzero_size = 0;
|
|
|
|
|
|
|
|
np = of_find_node_by_path("/memory@0");
|
|
|
|
if (np) {
|
2011-06-14 08:57:51 +08:00
|
|
|
if (!of_address_to_resource(np, 0, &r))
|
|
|
|
memzero_size = resource_size(&r);
|
2011-01-21 00:45:20 +08:00
|
|
|
of_node_put(np);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (memzero_size) {
|
|
|
|
/* We now know the size of memory@0, use this to find
|
|
|
|
* the first memoryblock and get its size.
|
|
|
|
*/
|
|
|
|
char buf[64];
|
|
|
|
|
|
|
|
sprintf(buf, "/memory@%x", memzero_size);
|
|
|
|
np = of_find_node_by_path(buf);
|
|
|
|
if (np) {
|
2011-06-14 08:57:51 +08:00
|
|
|
if (!of_address_to_resource(np, 0, &r))
|
|
|
|
memblock_size = resource_size(&r);
|
2011-01-21 00:45:20 +08:00
|
|
|
of_node_put(np);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return memblock_size;
|
|
|
|
}
|
|
|
|
|
2011-06-14 08:57:51 +08:00
|
|
|
/* WARNING: This is going to override the generic definition whenever
|
|
|
|
* pseries is built-in regardless of what platform is active at boot
|
|
|
|
* time. This is fine for now as this is the only "option" and it
|
|
|
|
* should work everywhere. If not, we'll have to turn this into a
|
|
|
|
* ppc_md. callback
|
|
|
|
*/
|
2011-01-21 00:45:20 +08:00
|
|
|
unsigned long memory_block_size_bytes(void)
|
|
|
|
{
|
|
|
|
return get_memblock_size();
|
|
|
|
}
|
|
|
|
|
2010-07-12 12:36:09 +08:00
|
|
|
static int pseries_remove_memblock(unsigned long base, unsigned int memblock_size)
|
2008-04-19 04:33:50 +08:00
|
|
|
{
|
2008-07-03 11:22:39 +08:00
|
|
|
unsigned long start, start_pfn;
|
2008-04-19 04:33:50 +08:00
|
|
|
struct zone *zone;
|
2008-07-03 11:22:39 +08:00
|
|
|
int ret;
|
2008-07-03 11:20:58 +08:00
|
|
|
|
2008-10-01 17:44:02 +08:00
|
|
|
start_pfn = base >> PAGE_SHIFT;
|
2008-10-13 16:42:00 +08:00
|
|
|
|
|
|
|
if (!pfn_valid(start_pfn)) {
|
2010-07-12 12:36:09 +08:00
|
|
|
memblock_remove(base, memblock_size);
|
2008-10-13 16:42:00 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-19 04:33:50 +08:00
|
|
|
zone = page_zone(pfn_to_page(start_pfn));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove section mappings and sysfs entries for the
|
|
|
|
* section of the memory we are removing.
|
|
|
|
*
|
|
|
|
* NOTE: Ideally, this should be done in generic code like
|
|
|
|
* remove_memory(). But remove_memory() gets called by writing
|
|
|
|
* to sysfs "state" file and we can't remove sysfs entries
|
|
|
|
* while writing to it. So we have to defer it to here.
|
|
|
|
*/
|
2010-07-12 12:36:09 +08:00
|
|
|
ret = __remove_pages(zone, start_pfn, memblock_size >> PAGE_SHIFT);
|
2008-04-19 04:33:50 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2008-04-19 04:33:52 +08:00
|
|
|
/*
|
|
|
|
* Update memory regions for memory remove
|
|
|
|
*/
|
2010-07-12 12:36:09 +08:00
|
|
|
memblock_remove(base, memblock_size);
|
2008-04-19 04:33:52 +08:00
|
|
|
|
2008-04-19 04:33:50 +08:00
|
|
|
/*
|
|
|
|
* Remove htab bolted mappings for this section of memory
|
|
|
|
*/
|
2008-07-03 11:20:58 +08:00
|
|
|
start = (unsigned long)__va(base);
|
2010-07-12 12:36:09 +08:00
|
|
|
ret = remove_section_mapping(start, start + memblock_size);
|
2010-04-06 23:03:40 +08:00
|
|
|
|
|
|
|
/* Ensure all vmalloc mappings are flushed in case they also
|
|
|
|
* hit that section of memory
|
|
|
|
*/
|
|
|
|
vm_unmap_aliases();
|
|
|
|
|
2008-04-19 04:33:50 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-07-03 11:22:39 +08:00
|
|
|
static int pseries_remove_memory(struct device_node *np)
|
|
|
|
{
|
|
|
|
const char *type;
|
|
|
|
const unsigned int *regs;
|
|
|
|
unsigned long base;
|
2010-07-23 08:35:52 +08:00
|
|
|
unsigned int lmb_size;
|
2008-07-03 11:22:39 +08:00
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check to see if we are actually removing memory
|
|
|
|
*/
|
|
|
|
type = of_get_property(np, "device_type", NULL);
|
|
|
|
if (type == NULL || strcmp(type, "memory") != 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
2010-07-12 12:36:09 +08:00
|
|
|
* Find the bae address and size of the memblock
|
2008-07-03 11:22:39 +08:00
|
|
|
*/
|
|
|
|
regs = of_get_property(np, "reg", NULL);
|
|
|
|
if (!regs)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
base = *(unsigned long *)regs;
|
2010-07-23 08:35:52 +08:00
|
|
|
lmb_size = regs[3];
|
2008-07-03 11:22:39 +08:00
|
|
|
|
2010-07-23 08:35:52 +08:00
|
|
|
ret = pseries_remove_memblock(base, lmb_size);
|
2008-07-03 11:22:39 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-04-19 04:33:52 +08:00
|
|
|
static int pseries_add_memory(struct device_node *np)
|
|
|
|
{
|
|
|
|
const char *type;
|
|
|
|
const unsigned int *regs;
|
2008-07-03 11:20:58 +08:00
|
|
|
unsigned long base;
|
2010-07-23 08:35:52 +08:00
|
|
|
unsigned int lmb_size;
|
2008-04-19 04:33:52 +08:00
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check to see if we are actually adding memory
|
|
|
|
*/
|
|
|
|
type = of_get_property(np, "device_type", NULL);
|
|
|
|
if (type == NULL || strcmp(type, "memory") != 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
2010-07-12 12:36:09 +08:00
|
|
|
* Find the base and size of the memblock
|
2008-04-19 04:33:52 +08:00
|
|
|
*/
|
|
|
|
regs = of_get_property(np, "reg", NULL);
|
|
|
|
if (!regs)
|
|
|
|
return ret;
|
|
|
|
|
2008-07-03 11:20:58 +08:00
|
|
|
base = *(unsigned long *)regs;
|
2010-07-23 08:35:52 +08:00
|
|
|
lmb_size = regs[3];
|
2008-04-19 04:33:52 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Update memory region to represent the memory add
|
|
|
|
*/
|
2010-07-23 08:35:52 +08:00
|
|
|
ret = memblock_add(base, lmb_size);
|
2008-07-03 11:22:39 +08:00
|
|
|
return (ret < 0) ? -EINVAL : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pseries_drconf_memory(unsigned long *base, unsigned int action)
|
|
|
|
{
|
2011-01-21 00:45:20 +08:00
|
|
|
unsigned long memblock_size;
|
2008-07-03 11:22:39 +08:00
|
|
|
int rc;
|
|
|
|
|
2011-01-21 00:45:20 +08:00
|
|
|
memblock_size = get_memblock_size();
|
|
|
|
if (!memblock_size)
|
2008-07-03 11:22:39 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (action == PSERIES_DRCONF_MEM_ADD) {
|
2011-01-21 00:45:20 +08:00
|
|
|
rc = memblock_add(*base, memblock_size);
|
2008-07-03 11:22:39 +08:00
|
|
|
rc = (rc < 0) ? -EINVAL : 0;
|
|
|
|
} else if (action == PSERIES_DRCONF_MEM_REMOVE) {
|
2011-01-21 00:45:20 +08:00
|
|
|
rc = pseries_remove_memblock(*base, memblock_size);
|
2008-07-03 11:22:39 +08:00
|
|
|
} else {
|
|
|
|
rc = -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rc;
|
2008-04-19 04:33:52 +08:00
|
|
|
}
|
|
|
|
|
2008-04-19 04:33:50 +08:00
|
|
|
static int pseries_memory_notifier(struct notifier_block *nb,
|
|
|
|
unsigned long action, void *node)
|
|
|
|
{
|
2011-06-21 11:35:56 +08:00
|
|
|
int err = 0;
|
2008-04-19 04:33:50 +08:00
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case PSERIES_RECONFIG_ADD:
|
2011-06-21 11:35:56 +08:00
|
|
|
err = pseries_add_memory(node);
|
2008-04-19 04:33:50 +08:00
|
|
|
break;
|
|
|
|
case PSERIES_RECONFIG_REMOVE:
|
2011-06-21 11:35:56 +08:00
|
|
|
err = pseries_remove_memory(node);
|
2008-04-19 04:33:50 +08:00
|
|
|
break;
|
2008-07-03 11:22:39 +08:00
|
|
|
case PSERIES_DRCONF_MEM_ADD:
|
|
|
|
case PSERIES_DRCONF_MEM_REMOVE:
|
2011-06-21 11:35:56 +08:00
|
|
|
err = pseries_drconf_memory(node, action);
|
2008-04-19 04:33:50 +08:00
|
|
|
break;
|
|
|
|
}
|
2011-06-21 11:35:56 +08:00
|
|
|
return notifier_from_errno(err);
|
2008-04-19 04:33:50 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block pseries_mem_nb = {
|
|
|
|
.notifier_call = pseries_memory_notifier,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init pseries_memory_hotplug_init(void)
|
|
|
|
{
|
|
|
|
if (firmware_has_feature(FW_FEATURE_LPAR))
|
|
|
|
pSeries_reconfig_notifier_register(&pseries_mem_nb);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
machine_device_initcall(pseries, pseries_memory_hotplug_init);
|