1eaefd661d36561d028118e46b90887b164631b9
[linux-2.6.git] / arch / powerpc / platforms / pseries / hotplug-memory.c
1 /*
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>
13 #include <linux/memblock.h>
14 #include <linux/vmalloc.h>
15 #include <asm/firmware.h>
16 #include <asm/machdep.h>
17 #include <asm/pSeries_reconfig.h>
18 #include <asm/sparsemem.h>
19
20 static unsigned long get_memblock_size(void)
21 {
22         struct device_node *np;
23         unsigned int memblock_size = 0;
24
25         np = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory");
26         if (np) {
27                 const unsigned long *size;
28
29                 size = of_get_property(np, "ibm,lmb-size", NULL);
30                 memblock_size = size ? *size : 0;
31
32                 of_node_put(np);
33         } else {
34                 unsigned int memzero_size = 0;
35                 const unsigned int *regs;
36
37                 np = of_find_node_by_path("/memory@0");
38                 if (np) {
39                         regs = of_get_property(np, "reg", NULL);
40                         memzero_size = regs ? regs[3] : 0;
41                         of_node_put(np);
42                 }
43
44                 if (memzero_size) {
45                         /* We now know the size of memory@0, use this to find
46                          * the first memoryblock and get its size.
47                          */
48                         char buf[64];
49
50                         sprintf(buf, "/memory@%x", memzero_size);
51                         np = of_find_node_by_path(buf);
52                         if (np) {
53                                 regs = of_get_property(np, "reg", NULL);
54                                 memblock_size = regs ? regs[3] : 0;
55                                 of_node_put(np);
56                         }
57                 }
58         }
59
60         return memblock_size;
61 }
62
63 unsigned long memory_block_size_bytes(void)
64 {
65         return get_memblock_size();
66 }
67
68 static int pseries_remove_memblock(unsigned long base, unsigned int memblock_size)
69 {
70         unsigned long start, start_pfn;
71         struct zone *zone;
72         int ret;
73
74         start_pfn = base >> PAGE_SHIFT;
75
76         if (!pfn_valid(start_pfn)) {
77                 memblock_remove(base, memblock_size);
78                 return 0;
79         }
80
81         zone = page_zone(pfn_to_page(start_pfn));
82
83         /*
84          * Remove section mappings and sysfs entries for the
85          * section of the memory we are removing.
86          *
87          * NOTE: Ideally, this should be done in generic code like
88          * remove_memory(). But remove_memory() gets called by writing
89          * to sysfs "state" file and we can't remove sysfs entries
90          * while writing to it. So we have to defer it to here.
91          */
92         ret = __remove_pages(zone, start_pfn, memblock_size >> PAGE_SHIFT);
93         if (ret)
94                 return ret;
95
96         /*
97          * Update memory regions for memory remove
98          */
99         memblock_remove(base, memblock_size);
100
101         /*
102          * Remove htab bolted mappings for this section of memory
103          */
104         start = (unsigned long)__va(base);
105         ret = remove_section_mapping(start, start + memblock_size);
106
107         /* Ensure all vmalloc mappings are flushed in case they also
108          * hit that section of memory
109          */
110         vm_unmap_aliases();
111
112         return ret;
113 }
114
115 static int pseries_remove_memory(struct device_node *np)
116 {
117         const char *type;
118         const unsigned int *regs;
119         unsigned long base;
120         unsigned int lmb_size;
121         int ret = -EINVAL;
122
123         /*
124          * Check to see if we are actually removing memory
125          */
126         type = of_get_property(np, "device_type", NULL);
127         if (type == NULL || strcmp(type, "memory") != 0)
128                 return 0;
129
130         /*
131          * Find the bae address and size of the memblock
132          */
133         regs = of_get_property(np, "reg", NULL);
134         if (!regs)
135                 return ret;
136
137         base = *(unsigned long *)regs;
138         lmb_size = regs[3];
139
140         ret = pseries_remove_memblock(base, lmb_size);
141         return ret;
142 }
143
144 static int pseries_add_memory(struct device_node *np)
145 {
146         const char *type;
147         const unsigned int *regs;
148         unsigned long base;
149         unsigned int lmb_size;
150         int ret = -EINVAL;
151
152         /*
153          * Check to see if we are actually adding memory
154          */
155         type = of_get_property(np, "device_type", NULL);
156         if (type == NULL || strcmp(type, "memory") != 0)
157                 return 0;
158
159         /*
160          * Find the base and size of the memblock
161          */
162         regs = of_get_property(np, "reg", NULL);
163         if (!regs)
164                 return ret;
165
166         base = *(unsigned long *)regs;
167         lmb_size = regs[3];
168
169         /*
170          * Update memory region to represent the memory add
171          */
172         ret = memblock_add(base, lmb_size);
173         return (ret < 0) ? -EINVAL : 0;
174 }
175
176 static int pseries_drconf_memory(unsigned long *base, unsigned int action)
177 {
178         unsigned long memblock_size;
179         int rc;
180
181         memblock_size = get_memblock_size();
182         if (!memblock_size)
183                 return -EINVAL;
184
185         if (action == PSERIES_DRCONF_MEM_ADD) {
186                 rc = memblock_add(*base, memblock_size);
187                 rc = (rc < 0) ? -EINVAL : 0;
188         } else if (action == PSERIES_DRCONF_MEM_REMOVE) {
189                 rc = pseries_remove_memblock(*base, memblock_size);
190         } else {
191                 rc = -EINVAL;
192         }
193
194         return rc;
195 }
196
197 static int pseries_memory_notifier(struct notifier_block *nb,
198                                 unsigned long action, void *node)
199 {
200         int err = 0;
201
202         switch (action) {
203         case PSERIES_RECONFIG_ADD:
204                 err = pseries_add_memory(node);
205                 break;
206         case PSERIES_RECONFIG_REMOVE:
207                 err = pseries_remove_memory(node);
208                 break;
209         case PSERIES_DRCONF_MEM_ADD:
210         case PSERIES_DRCONF_MEM_REMOVE:
211                 err = pseries_drconf_memory(node, action);
212                 break;
213         }
214         return notifier_from_errno(err);
215 }
216
217 static struct notifier_block pseries_mem_nb = {
218         .notifier_call = pseries_memory_notifier,
219 };
220
221 static int __init pseries_memory_hotplug_init(void)
222 {
223         if (firmware_has_feature(FW_FEATURE_LPAR))
224                 pSeries_reconfig_notifier_register(&pseries_mem_nb);
225
226         return 0;
227 }
228 machine_device_initcall(pseries, pseries_memory_hotplug_init);