blob: 7995135170a31a35a7824703f72fe26b93b145a7 [file] [log] [blame]
Badari Pulavarty57b53922008-04-18 13:33:50 -07001/*
2 * pseries Memory Hotplug infrastructure.
3 *
4 * Copyright (C) 2008 Badari Pulavarty, IBM Corporation
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 */
11
12#include <linux/of.h>
Rob Herring26a20562013-09-26 07:40:04 -050013#include <linux/of_address.h>
Yinghai Lu95f72d12010-07-12 14:36:09 +100014#include <linux/memblock.h>
Benjamin Herrenschmidtb4a26be2010-04-06 15:03:40 +000015#include <linux/vmalloc.h>
Benjamin Herrenschmidt770e1ac2011-06-14 10:57:51 +100016#include <linux/memory.h>
Nathan Fontenot9ac8cde2014-01-27 10:54:06 -060017#include <linux/memory_hotplug.h>
Benjamin Herrenschmidt770e1ac2011-06-14 10:57:51 +100018
Badari Pulavarty57b53922008-04-18 13:33:50 -070019#include <asm/firmware.h>
20#include <asm/machdep.h>
Rob Herring26a20562013-09-26 07:40:04 -050021#include <asm/prom.h>
Michael Neuling0b2f8282009-02-08 14:49:39 +000022#include <asm/sparsemem.h>
Badari Pulavarty57b53922008-04-18 13:33:50 -070023
Anton Blancharda5d86252014-06-04 17:50:47 +100024unsigned long pseries_memory_block_size(void)
Nathan Fontenotc540ada2011-01-20 10:45:20 -060025{
26 struct device_node *np;
Benjamin Herrenschmidt770e1ac2011-06-14 10:57:51 +100027 unsigned int memblock_size = MIN_MEMORY_BLOCK_SIZE;
28 struct resource r;
Nathan Fontenotc540ada2011-01-20 10:45:20 -060029
30 np = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory");
31 if (np) {
Benjamin Herrenschmidt770e1ac2011-06-14 10:57:51 +100032 const __be64 *size;
Nathan Fontenotc540ada2011-01-20 10:45:20 -060033
34 size = of_get_property(np, "ibm,lmb-size", NULL);
Benjamin Herrenschmidt770e1ac2011-06-14 10:57:51 +100035 if (size)
36 memblock_size = be64_to_cpup(size);
Nathan Fontenotc540ada2011-01-20 10:45:20 -060037 of_node_put(np);
Benjamin Herrenschmidt770e1ac2011-06-14 10:57:51 +100038 } else if (machine_is(pseries)) {
39 /* This fallback really only applies to pseries */
Nathan Fontenotc540ada2011-01-20 10:45:20 -060040 unsigned int memzero_size = 0;
Nathan Fontenotc540ada2011-01-20 10:45:20 -060041
42 np = of_find_node_by_path("/memory@0");
43 if (np) {
Benjamin Herrenschmidt770e1ac2011-06-14 10:57:51 +100044 if (!of_address_to_resource(np, 0, &r))
45 memzero_size = resource_size(&r);
Nathan Fontenotc540ada2011-01-20 10:45:20 -060046 of_node_put(np);
47 }
48
49 if (memzero_size) {
50 /* We now know the size of memory@0, use this to find
51 * the first memoryblock and get its size.
52 */
53 char buf[64];
54
55 sprintf(buf, "/memory@%x", memzero_size);
56 np = of_find_node_by_path(buf);
57 if (np) {
Benjamin Herrenschmidt770e1ac2011-06-14 10:57:51 +100058 if (!of_address_to_resource(np, 0, &r))
59 memblock_size = resource_size(&r);
Nathan Fontenotc540ada2011-01-20 10:45:20 -060060 of_node_put(np);
61 }
62 }
63 }
Nathan Fontenotc540ada2011-01-20 10:45:20 -060064 return memblock_size;
65}
66
David Rientjes4edd7ce2013-04-29 15:08:22 -070067#ifdef CONFIG_MEMORY_HOTREMOVE
Nathan Fontenot9ac8cde2014-01-27 10:54:06 -060068static int pseries_remove_memory(u64 start, u64 size)
Badari Pulavarty57b53922008-04-18 13:33:50 -070069{
Yasuaki Ishimatsu1633dbb2012-10-10 15:53:53 -070070 int ret;
Nathan Fontenot92ecd172008-07-03 13:20:58 +100071
Nathan Fontenot9ac8cde2014-01-27 10:54:06 -060072 /* Remove htab bolted mappings for this section of memory */
73 start = (unsigned long)__va(start);
74 ret = remove_section_mapping(start, start + size);
Benjamin Herrenschmidtb4a26be2010-04-06 15:03:40 +000075
76 /* Ensure all vmalloc mappings are flushed in case they also
77 * hit that section of memory
78 */
79 vm_unmap_aliases();
80
Badari Pulavarty57b53922008-04-18 13:33:50 -070081 return ret;
82}
83
Nathan Fontenot9ac8cde2014-01-27 10:54:06 -060084static int pseries_remove_memblock(unsigned long base, unsigned int memblock_size)
85{
86 unsigned long block_sz, start_pfn;
87 int sections_per_block;
88 int i, nid;
89
90 start_pfn = base >> PAGE_SHIFT;
91
Li Zhong42dbfc82014-04-10 16:25:31 +080092 lock_device_hotplug();
93
94 if (!pfn_valid(start_pfn))
95 goto out;
Nathan Fontenot9ac8cde2014-01-27 10:54:06 -060096
Anton Blancharda5d86252014-06-04 17:50:47 +100097 block_sz = pseries_memory_block_size();
Nathan Fontenot9ac8cde2014-01-27 10:54:06 -060098 sections_per_block = block_sz / MIN_MEMORY_BLOCK_SIZE;
99 nid = memory_add_physaddr_to_nid(base);
100
101 for (i = 0; i < sections_per_block; i++) {
102 remove_memory(nid, base, MIN_MEMORY_BLOCK_SIZE);
103 base += MIN_MEMORY_BLOCK_SIZE;
104 }
105
Li Zhong42dbfc82014-04-10 16:25:31 +0800106out:
Nathan Fontenot9ac8cde2014-01-27 10:54:06 -0600107 /* Update memory regions for memory remove */
108 memblock_remove(base, memblock_size);
Li Zhong42dbfc82014-04-10 16:25:31 +0800109 unlock_device_hotplug();
Nathan Fontenot9ac8cde2014-01-27 10:54:06 -0600110 return 0;
111}
112
113static int pseries_remove_mem_node(struct device_node *np)
Nathan Fontenot3c3f67e2008-07-03 13:22:39 +1000114{
115 const char *type;
116 const unsigned int *regs;
117 unsigned long base;
Benjamin Herrenschmidt3fdfd992010-07-23 10:35:52 +1000118 unsigned int lmb_size;
Nathan Fontenot3c3f67e2008-07-03 13:22:39 +1000119 int ret = -EINVAL;
120
121 /*
122 * Check to see if we are actually removing memory
123 */
124 type = of_get_property(np, "device_type", NULL);
125 if (type == NULL || strcmp(type, "memory") != 0)
126 return 0;
127
128 /*
Yinghai Lu95f72d12010-07-12 14:36:09 +1000129 * Find the bae address and size of the memblock
Nathan Fontenot3c3f67e2008-07-03 13:22:39 +1000130 */
131 regs = of_get_property(np, "reg", NULL);
132 if (!regs)
133 return ret;
134
135 base = *(unsigned long *)regs;
Benjamin Herrenschmidt3fdfd992010-07-23 10:35:52 +1000136 lmb_size = regs[3];
Nathan Fontenot3c3f67e2008-07-03 13:22:39 +1000137
Nathan Fontenot9ac8cde2014-01-27 10:54:06 -0600138 pseries_remove_memblock(base, lmb_size);
139 return 0;
Nathan Fontenot3c3f67e2008-07-03 13:22:39 +1000140}
David Rientjes4edd7ce2013-04-29 15:08:22 -0700141#else
142static inline int pseries_remove_memblock(unsigned long base,
143 unsigned int memblock_size)
144{
145 return -EOPNOTSUPP;
146}
Nathan Fontenot9ac8cde2014-01-27 10:54:06 -0600147static inline int pseries_remove_mem_node(struct device_node *np)
David Rientjes4edd7ce2013-04-29 15:08:22 -0700148{
149 return -EOPNOTSUPP;
150}
151#endif /* CONFIG_MEMORY_HOTREMOVE */
Nathan Fontenot3c3f67e2008-07-03 13:22:39 +1000152
Nathan Fontenot9ac8cde2014-01-27 10:54:06 -0600153static int pseries_add_mem_node(struct device_node *np)
Badari Pulavarty98d5c212008-04-18 13:33:52 -0700154{
155 const char *type;
Badari Pulavarty98d5c212008-04-18 13:33:52 -0700156 const unsigned int *regs;
Nathan Fontenot92ecd172008-07-03 13:20:58 +1000157 unsigned long base;
Benjamin Herrenschmidt3fdfd992010-07-23 10:35:52 +1000158 unsigned int lmb_size;
Badari Pulavarty98d5c212008-04-18 13:33:52 -0700159 int ret = -EINVAL;
160
161 /*
162 * Check to see if we are actually adding memory
163 */
164 type = of_get_property(np, "device_type", NULL);
165 if (type == NULL || strcmp(type, "memory") != 0)
166 return 0;
167
168 /*
Yinghai Lu95f72d12010-07-12 14:36:09 +1000169 * Find the base and size of the memblock
Badari Pulavarty98d5c212008-04-18 13:33:52 -0700170 */
Badari Pulavarty98d5c212008-04-18 13:33:52 -0700171 regs = of_get_property(np, "reg", NULL);
172 if (!regs)
173 return ret;
174
Nathan Fontenot92ecd172008-07-03 13:20:58 +1000175 base = *(unsigned long *)regs;
Benjamin Herrenschmidt3fdfd992010-07-23 10:35:52 +1000176 lmb_size = regs[3];
Badari Pulavarty98d5c212008-04-18 13:33:52 -0700177
178 /*
179 * Update memory region to represent the memory add
180 */
Benjamin Herrenschmidt3fdfd992010-07-23 10:35:52 +1000181 ret = memblock_add(base, lmb_size);
Nathan Fontenot3c3f67e2008-07-03 13:22:39 +1000182 return (ret < 0) ? -EINVAL : 0;
183}
184
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +0000185static int pseries_update_drconf_memory(struct of_prop_reconfig *pr)
Nathan Fontenot3c3f67e2008-07-03 13:22:39 +1000186{
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +0000187 struct of_drconf_cell *new_drmem, *old_drmem;
Nathan Fontenotc540ada2011-01-20 10:45:20 -0600188 unsigned long memblock_size;
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +0000189 u32 entries;
190 u32 *p;
191 int i, rc = -EINVAL;
Nathan Fontenot3c3f67e2008-07-03 13:22:39 +1000192
Anton Blancharda5d86252014-06-04 17:50:47 +1000193 memblock_size = pseries_memory_block_size();
Nathan Fontenotc540ada2011-01-20 10:45:20 -0600194 if (!memblock_size)
Nathan Fontenot3c3f67e2008-07-03 13:22:39 +1000195 return -EINVAL;
196
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +0000197 p = (u32 *)of_get_property(pr->dn, "ibm,dynamic-memory", NULL);
198 if (!p)
199 return -EINVAL;
200
201 /* The first int of the property is the number of lmb's described
202 * by the property. This is followed by an array of of_drconf_cell
203 * entries. Get the niumber of entries and skip to the array of
204 * of_drconf_cell's.
205 */
206 entries = *p++;
207 old_drmem = (struct of_drconf_cell *)p;
208
209 p = (u32 *)pr->prop->value;
210 p++;
211 new_drmem = (struct of_drconf_cell *)p;
212
213 for (i = 0; i < entries; i++) {
214 if ((old_drmem[i].flags & DRCONF_MEM_ASSIGNED) &&
215 (!(new_drmem[i].flags & DRCONF_MEM_ASSIGNED))) {
216 rc = pseries_remove_memblock(old_drmem[i].base_addr,
217 memblock_size);
218 break;
219 } else if ((!(old_drmem[i].flags & DRCONF_MEM_ASSIGNED)) &&
220 (new_drmem[i].flags & DRCONF_MEM_ASSIGNED)) {
221 rc = memblock_add(old_drmem[i].base_addr,
222 memblock_size);
223 rc = (rc < 0) ? -EINVAL : 0;
224 break;
225 }
Nathan Fontenot3c3f67e2008-07-03 13:22:39 +1000226 }
227
Nathan Fontenot3c3f67e2008-07-03 13:22:39 +1000228 return rc;
Badari Pulavarty98d5c212008-04-18 13:33:52 -0700229}
230
Badari Pulavarty57b53922008-04-18 13:33:50 -0700231static int pseries_memory_notifier(struct notifier_block *nb,
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +0000232 unsigned long action, void *node)
Badari Pulavarty57b53922008-04-18 13:33:50 -0700233{
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +0000234 struct of_prop_reconfig *pr;
Akinobu Mitade2780a2011-06-21 03:35:56 +0000235 int err = 0;
Badari Pulavarty57b53922008-04-18 13:33:50 -0700236
237 switch (action) {
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +0000238 case OF_RECONFIG_ATTACH_NODE:
Nathan Fontenot9ac8cde2014-01-27 10:54:06 -0600239 err = pseries_add_mem_node(node);
Badari Pulavarty57b53922008-04-18 13:33:50 -0700240 break;
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +0000241 case OF_RECONFIG_DETACH_NODE:
Nathan Fontenot9ac8cde2014-01-27 10:54:06 -0600242 err = pseries_remove_mem_node(node);
Badari Pulavarty57b53922008-04-18 13:33:50 -0700243 break;
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +0000244 case OF_RECONFIG_UPDATE_PROPERTY:
245 pr = (struct of_prop_reconfig *)node;
246 if (!strcmp(pr->prop->name, "ibm,dynamic-memory"))
247 err = pseries_update_drconf_memory(pr);
Badari Pulavarty57b53922008-04-18 13:33:50 -0700248 break;
249 }
Akinobu Mitade2780a2011-06-21 03:35:56 +0000250 return notifier_from_errno(err);
Badari Pulavarty57b53922008-04-18 13:33:50 -0700251}
252
253static struct notifier_block pseries_mem_nb = {
254 .notifier_call = pseries_memory_notifier,
255};
256
257static int __init pseries_memory_hotplug_init(void)
258{
259 if (firmware_has_feature(FW_FEATURE_LPAR))
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +0000260 of_reconfig_notifier_register(&pseries_mem_nb);
Badari Pulavarty57b53922008-04-18 13:33:50 -0700261
Nathan Fontenot9ac8cde2014-01-27 10:54:06 -0600262#ifdef CONFIG_MEMORY_HOTREMOVE
263 ppc_md.remove_memory = pseries_remove_memory;
264#endif
265
Badari Pulavarty57b53922008-04-18 13:33:50 -0700266 return 0;
267}
268machine_device_initcall(pseries, pseries_memory_hotplug_init);