cf4bffba6f7cb3357feec5f47698cd0a8882a117
[linux-2.6.git] / arch / powerpc / mm / numa.c
1 /*
2  * pSeries NUMA support
3  *
4  * Copyright (C) 2002 Anton Blanchard <anton@au.ibm.com>, IBM
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 #include <linux/threads.h>
12 #include <linux/bootmem.h>
13 #include <linux/init.h>
14 #include <linux/mm.h>
15 #include <linux/mmzone.h>
16 #include <linux/module.h>
17 #include <linux/nodemask.h>
18 #include <linux/cpu.h>
19 #include <linux/notifier.h>
20 #include <linux/lmb.h>
21 #include <linux/of.h>
22 #include <asm/sparsemem.h>
23 #include <asm/prom.h>
24 #include <asm/system.h>
25 #include <asm/smp.h>
26
27 static int numa_enabled = 1;
28
29 static char *cmdline __initdata;
30
31 static int numa_debug;
32 #define dbg(args...) if (numa_debug) { printk(KERN_INFO args); }
33
34 int numa_cpu_lookup_table[NR_CPUS];
35 cpumask_t numa_cpumask_lookup_table[MAX_NUMNODES];
36 struct pglist_data *node_data[MAX_NUMNODES];
37
38 EXPORT_SYMBOL(numa_cpu_lookup_table);
39 EXPORT_SYMBOL(numa_cpumask_lookup_table);
40 EXPORT_SYMBOL(node_data);
41
42 static bootmem_data_t __initdata plat_node_bdata[MAX_NUMNODES];
43 static int min_common_depth;
44 static int n_mem_addr_cells, n_mem_size_cells;
45
46 static int __cpuinit fake_numa_create_new_node(unsigned long end_pfn,
47                                                 unsigned int *nid)
48 {
49         unsigned long long mem;
50         char *p = cmdline;
51         static unsigned int fake_nid;
52         static unsigned long long curr_boundary;
53
54         /*
55          * Modify node id, iff we started creating NUMA nodes
56          * We want to continue from where we left of the last time
57          */
58         if (fake_nid)
59                 *nid = fake_nid;
60         /*
61          * In case there are no more arguments to parse, the
62          * node_id should be the same as the last fake node id
63          * (we've handled this above).
64          */
65         if (!p)
66                 return 0;
67
68         mem = memparse(p, &p);
69         if (!mem)
70                 return 0;
71
72         if (mem < curr_boundary)
73                 return 0;
74
75         curr_boundary = mem;
76
77         if ((end_pfn << PAGE_SHIFT) > mem) {
78                 /*
79                  * Skip commas and spaces
80                  */
81                 while (*p == ',' || *p == ' ' || *p == '\t')
82                         p++;
83
84                 cmdline = p;
85                 fake_nid++;
86                 *nid = fake_nid;
87                 dbg("created new fake_node with id %d\n", fake_nid);
88                 return 1;
89         }
90         return 0;
91 }
92
93 static void __cpuinit map_cpu_to_node(int cpu, int node)
94 {
95         numa_cpu_lookup_table[cpu] = node;
96
97         dbg("adding cpu %d to node %d\n", cpu, node);
98
99         if (!(cpu_isset(cpu, numa_cpumask_lookup_table[node])))
100                 cpu_set(cpu, numa_cpumask_lookup_table[node]);
101 }
102
103 #ifdef CONFIG_HOTPLUG_CPU
104 static void unmap_cpu_from_node(unsigned long cpu)
105 {
106         int node = numa_cpu_lookup_table[cpu];
107
108         dbg("removing cpu %lu from node %d\n", cpu, node);
109
110         if (cpu_isset(cpu, numa_cpumask_lookup_table[node])) {
111                 cpu_clear(cpu, numa_cpumask_lookup_table[node]);
112         } else {
113                 printk(KERN_ERR "WARNING: cpu %lu not found in node %d\n",
114                        cpu, node);
115         }
116 }
117 #endif /* CONFIG_HOTPLUG_CPU */
118
119 static struct device_node * __cpuinit find_cpu_node(unsigned int cpu)
120 {
121         unsigned int hw_cpuid = get_hard_smp_processor_id(cpu);
122         struct device_node *cpu_node = NULL;
123         const unsigned int *interrupt_server, *reg;
124         int len;
125
126         while ((cpu_node = of_find_node_by_type(cpu_node, "cpu")) != NULL) {
127                 /* Try interrupt server first */
128                 interrupt_server = of_get_property(cpu_node,
129                                         "ibm,ppc-interrupt-server#s", &len);
130
131                 len = len / sizeof(u32);
132
133                 if (interrupt_server && (len > 0)) {
134                         while (len--) {
135                                 if (interrupt_server[len] == hw_cpuid)
136                                         return cpu_node;
137                         }
138                 } else {
139                         reg = of_get_property(cpu_node, "reg", &len);
140                         if (reg && (len > 0) && (reg[0] == hw_cpuid))
141                                 return cpu_node;
142                 }
143         }
144
145         return NULL;
146 }
147
148 /* must hold reference to node during call */
149 static const int *of_get_associativity(struct device_node *dev)
150 {
151         return of_get_property(dev, "ibm,associativity", NULL);
152 }
153
154 /* Returns nid in the range [0..MAX_NUMNODES-1], or -1 if no useful numa
155  * info is found.
156  */
157 static int of_node_to_nid_single(struct device_node *device)
158 {
159         int nid = -1;
160         const unsigned int *tmp;
161
162         if (min_common_depth == -1)
163                 goto out;
164
165         tmp = of_get_associativity(device);
166         if (!tmp)
167                 goto out;
168
169         if (tmp[0] >= min_common_depth)
170                 nid = tmp[min_common_depth];
171
172         /* POWER4 LPAR uses 0xffff as invalid node */
173         if (nid == 0xffff || nid >= MAX_NUMNODES)
174                 nid = -1;
175 out:
176         return nid;
177 }
178
179 /* Walk the device tree upwards, looking for an associativity id */
180 int of_node_to_nid(struct device_node *device)
181 {
182         struct device_node *tmp;
183         int nid = -1;
184
185         of_node_get(device);
186         while (device) {
187                 nid = of_node_to_nid_single(device);
188                 if (nid != -1)
189                         break;
190
191                 tmp = device;
192                 device = of_get_parent(tmp);
193                 of_node_put(tmp);
194         }
195         of_node_put(device);
196
197         return nid;
198 }
199 EXPORT_SYMBOL_GPL(of_node_to_nid);
200
201 /*
202  * In theory, the "ibm,associativity" property may contain multiple
203  * associativity lists because a resource may be multiply connected
204  * into the machine.  This resource then has different associativity
205  * characteristics relative to its multiple connections.  We ignore
206  * this for now.  We also assume that all cpu and memory sets have
207  * their distances represented at a common level.  This won't be
208  * true for hierarchical NUMA.
209  *
210  * In any case the ibm,associativity-reference-points should give
211  * the correct depth for a normal NUMA system.
212  *
213  * - Dave Hansen <haveblue@us.ibm.com>
214  */
215 static int __init find_min_common_depth(void)
216 {
217         int depth;
218         const unsigned int *ref_points;
219         struct device_node *rtas_root;
220         unsigned int len;
221
222         rtas_root = of_find_node_by_path("/rtas");
223
224         if (!rtas_root)
225                 return -1;
226
227         /*
228          * this property is 2 32-bit integers, each representing a level of
229          * depth in the associativity nodes.  The first is for an SMP
230          * configuration (should be all 0's) and the second is for a normal
231          * NUMA configuration.
232          */
233         ref_points = of_get_property(rtas_root,
234                         "ibm,associativity-reference-points", &len);
235
236         if ((len >= 1) && ref_points) {
237                 depth = ref_points[1];
238         } else {
239                 dbg("NUMA: ibm,associativity-reference-points not found.\n");
240                 depth = -1;
241         }
242         of_node_put(rtas_root);
243
244         return depth;
245 }
246
247 static void __init get_n_mem_cells(int *n_addr_cells, int *n_size_cells)
248 {
249         struct device_node *memory = NULL;
250
251         memory = of_find_node_by_type(memory, "memory");
252         if (!memory)
253                 panic("numa.c: No memory nodes found!");
254
255         *n_addr_cells = of_n_addr_cells(memory);
256         *n_size_cells = of_n_size_cells(memory);
257         of_node_put(memory);
258 }
259
260 static unsigned long __devinit read_n_cells(int n, const unsigned int **buf)
261 {
262         unsigned long result = 0;
263
264         while (n--) {
265                 result = (result << 32) | **buf;
266                 (*buf)++;
267         }
268         return result;
269 }
270
271 struct of_drconf_cell {
272         u64     base_addr;
273         u32     drc_index;
274         u32     reserved;
275         u32     aa_index;
276         u32     flags;
277 };
278
279 #define DRCONF_MEM_ASSIGNED     0x00000008
280 #define DRCONF_MEM_AI_INVALID   0x00000040
281 #define DRCONF_MEM_RESERVED     0x00000080
282
283 /*
284  * Read the next lmb list entry from the ibm,dynamic-memory property
285  * and return the information in the provided of_drconf_cell structure.
286  */
287 static void read_drconf_cell(struct of_drconf_cell *drmem, const u32 **cellp)
288 {
289         const u32 *cp;
290
291         drmem->base_addr = read_n_cells(n_mem_addr_cells, cellp);
292
293         cp = *cellp;
294         drmem->drc_index = cp[0];
295         drmem->reserved = cp[1];
296         drmem->aa_index = cp[2];
297         drmem->flags = cp[3];
298
299         *cellp = cp + 4;
300 }
301
302 /*
303  * Retreive and validate the ibm,dynamic-memory property of the device tree.
304  *
305  * The layout of the ibm,dynamic-memory property is a number N of lmb
306  * list entries followed by N lmb list entries.  Each lmb list entry
307  * contains information as layed out in the of_drconf_cell struct above.
308  */
309 static int of_get_drconf_memory(struct device_node *memory, const u32 **dm)
310 {
311         const u32 *prop;
312         u32 len, entries;
313
314         prop = of_get_property(memory, "ibm,dynamic-memory", &len);
315         if (!prop || len < sizeof(unsigned int))
316                 return 0;
317
318         entries = *prop++;
319
320         /* Now that we know the number of entries, revalidate the size
321          * of the property read in to ensure we have everything
322          */
323         if (len < (entries * (n_mem_addr_cells + 4) + 1) * sizeof(unsigned int))
324                 return 0;
325
326         *dm = prop;
327         return entries;
328 }
329
330 /*
331  * Retreive and validate the ibm,lmb-size property for drconf memory
332  * from the device tree.
333  */
334 static u64 of_get_lmb_size(struct device_node *memory)
335 {
336         const u32 *prop;
337         u32 len;
338
339         prop = of_get_property(memory, "ibm,lmb-size", &len);
340         if (!prop || len < sizeof(unsigned int))
341                 return 0;
342
343         return read_n_cells(n_mem_size_cells, &prop);
344 }
345
346 struct assoc_arrays {
347         u32     n_arrays;
348         u32     array_sz;
349         const u32 *arrays;
350 };
351
352 /*
353  * Retreive and validate the list of associativity arrays for drconf
354  * memory from the ibm,associativity-lookup-arrays property of the
355  * device tree..
356  *
357  * The layout of the ibm,associativity-lookup-arrays property is a number N
358  * indicating the number of associativity arrays, followed by a number M
359  * indicating the size of each associativity array, followed by a list
360  * of N associativity arrays.
361  */
362 static int of_get_assoc_arrays(struct device_node *memory,
363                                struct assoc_arrays *aa)
364 {
365         const u32 *prop;
366         u32 len;
367
368         prop = of_get_property(memory, "ibm,associativity-lookup-arrays", &len);
369         if (!prop || len < 2 * sizeof(unsigned int))
370                 return -1;
371
372         aa->n_arrays = *prop++;
373         aa->array_sz = *prop++;
374
375         /* Now that we know the number of arrrays and size of each array,
376          * revalidate the size of the property read in.
377          */
378         if (len < (aa->n_arrays * aa->array_sz + 2) * sizeof(unsigned int))
379                 return -1;
380
381         aa->arrays = prop;
382         return 0;
383 }
384
385 /*
386  * This is like of_node_to_nid_single() for memory represented in the
387  * ibm,dynamic-reconfiguration-memory node.
388  */
389 static int of_drconf_to_nid_single(struct of_drconf_cell *drmem,
390                                    struct assoc_arrays *aa)
391 {
392         int default_nid = 0;
393         int nid = default_nid;
394         int index;
395
396         if (min_common_depth > 0 && min_common_depth <= aa->array_sz &&
397             !(drmem->flags & DRCONF_MEM_AI_INVALID) &&
398             drmem->aa_index < aa->n_arrays) {
399                 index = drmem->aa_index * aa->array_sz + min_common_depth - 1;
400                 nid = aa->arrays[index];
401
402                 if (nid == 0xffff || nid >= MAX_NUMNODES)
403                         nid = default_nid;
404         }
405
406         return nid;
407 }
408
409 /*
410  * Figure out to which domain a cpu belongs and stick it there.
411  * Return the id of the domain used.
412  */
413 static int __cpuinit numa_setup_cpu(unsigned long lcpu)
414 {
415         int nid = 0;
416         struct device_node *cpu = find_cpu_node(lcpu);
417
418         if (!cpu) {
419                 WARN_ON(1);
420                 goto out;
421         }
422
423         nid = of_node_to_nid_single(cpu);
424
425         if (nid < 0 || !node_online(nid))
426                 nid = any_online_node(NODE_MASK_ALL);
427 out:
428         map_cpu_to_node(lcpu, nid);
429
430         of_node_put(cpu);
431
432         return nid;
433 }
434
435 static int __cpuinit cpu_numa_callback(struct notifier_block *nfb,
436                              unsigned long action,
437                              void *hcpu)
438 {
439         unsigned long lcpu = (unsigned long)hcpu;
440         int ret = NOTIFY_DONE;
441
442         switch (action) {
443         case CPU_UP_PREPARE:
444         case CPU_UP_PREPARE_FROZEN:
445                 numa_setup_cpu(lcpu);
446                 ret = NOTIFY_OK;
447                 break;
448 #ifdef CONFIG_HOTPLUG_CPU
449         case CPU_DEAD:
450         case CPU_DEAD_FROZEN:
451         case CPU_UP_CANCELED:
452         case CPU_UP_CANCELED_FROZEN:
453                 unmap_cpu_from_node(lcpu);
454                 break;
455                 ret = NOTIFY_OK;
456 #endif
457         }
458         return ret;
459 }
460
461 /*
462  * Check and possibly modify a memory region to enforce the memory limit.
463  *
464  * Returns the size the region should have to enforce the memory limit.
465  * This will either be the original value of size, a truncated value,
466  * or zero. If the returned value of size is 0 the region should be
467  * discarded as it lies wholy above the memory limit.
468  */
469 static unsigned long __init numa_enforce_memory_limit(unsigned long start,
470                                                       unsigned long size)
471 {
472         /*
473          * We use lmb_end_of_DRAM() in here instead of memory_limit because
474          * we've already adjusted it for the limit and it takes care of
475          * having memory holes below the limit.
476          */
477
478         if (! memory_limit)
479                 return size;
480
481         if (start + size <= lmb_end_of_DRAM())
482                 return size;
483
484         if (start >= lmb_end_of_DRAM())
485                 return 0;
486
487         return lmb_end_of_DRAM() - start;
488 }
489
490 /*
491  * Extract NUMA information from the ibm,dynamic-reconfiguration-memory
492  * node.  This assumes n_mem_{addr,size}_cells have been set.
493  */
494 static void __init parse_drconf_memory(struct device_node *memory)
495 {
496         const u32 *dm;
497         unsigned int n, rc;
498         unsigned long lmb_size, size;
499         int nid;
500         struct assoc_arrays aa;
501
502         n = of_get_drconf_memory(memory, &dm);
503         if (!n)
504                 return;
505
506         lmb_size = of_get_lmb_size(memory);
507         if (!lmb_size)
508                 return;
509
510         rc = of_get_assoc_arrays(memory, &aa);
511         if (rc)
512                 return;
513
514         for (; n != 0; --n) {
515                 struct of_drconf_cell drmem;
516
517                 read_drconf_cell(&drmem, &dm);
518
519                 /* skip this block if the reserved bit is set in flags (0x80)
520                    or if the block is not assigned to this partition (0x8) */
521                 if ((drmem.flags & DRCONF_MEM_RESERVED)
522                     || !(drmem.flags & DRCONF_MEM_ASSIGNED))
523                         continue;
524
525                 nid = of_drconf_to_nid_single(&drmem, &aa);
526
527                 fake_numa_create_new_node(
528                                 ((drmem.base_addr + lmb_size) >> PAGE_SHIFT),
529                                            &nid);
530
531                 node_set_online(nid);
532
533                 size = numa_enforce_memory_limit(drmem.base_addr, lmb_size);
534                 if (!size)
535                         continue;
536
537                 add_active_range(nid, drmem.base_addr >> PAGE_SHIFT,
538                                  (drmem.base_addr >> PAGE_SHIFT)
539                                  + (size >> PAGE_SHIFT));
540         }
541 }
542
543 static int __init parse_numa_properties(void)
544 {
545         struct device_node *cpu = NULL;
546         struct device_node *memory = NULL;
547         int default_nid = 0;
548         unsigned long i;
549
550         if (numa_enabled == 0) {
551                 printk(KERN_WARNING "NUMA disabled by user\n");
552                 return -1;
553         }
554
555         min_common_depth = find_min_common_depth();
556
557         if (min_common_depth < 0)
558                 return min_common_depth;
559
560         dbg("NUMA associativity depth for CPU/Memory: %d\n", min_common_depth);
561
562         /*
563          * Even though we connect cpus to numa domains later in SMP
564          * init, we need to know the node ids now. This is because
565          * each node to be onlined must have NODE_DATA etc backing it.
566          */
567         for_each_present_cpu(i) {
568                 int nid;
569
570                 cpu = find_cpu_node(i);
571                 BUG_ON(!cpu);
572                 nid = of_node_to_nid_single(cpu);
573                 of_node_put(cpu);
574
575                 /*
576                  * Don't fall back to default_nid yet -- we will plug
577                  * cpus into nodes once the memory scan has discovered
578                  * the topology.
579                  */
580                 if (nid < 0)
581                         continue;
582                 node_set_online(nid);
583         }
584
585         get_n_mem_cells(&n_mem_addr_cells, &n_mem_size_cells);
586         memory = NULL;
587         while ((memory = of_find_node_by_type(memory, "memory")) != NULL) {
588                 unsigned long start;
589                 unsigned long size;
590                 int nid;
591                 int ranges;
592                 const unsigned int *memcell_buf;
593                 unsigned int len;
594
595                 memcell_buf = of_get_property(memory,
596                         "linux,usable-memory", &len);
597                 if (!memcell_buf || len <= 0)
598                         memcell_buf = of_get_property(memory, "reg", &len);
599                 if (!memcell_buf || len <= 0)
600                         continue;
601
602                 /* ranges in cell */
603                 ranges = (len >> 2) / (n_mem_addr_cells + n_mem_size_cells);
604 new_range:
605                 /* these are order-sensitive, and modify the buffer pointer */
606                 start = read_n_cells(n_mem_addr_cells, &memcell_buf);
607                 size = read_n_cells(n_mem_size_cells, &memcell_buf);
608
609                 /*
610                  * Assumption: either all memory nodes or none will
611                  * have associativity properties.  If none, then
612                  * everything goes to default_nid.
613                  */
614                 nid = of_node_to_nid_single(memory);
615                 if (nid < 0)
616                         nid = default_nid;
617
618                 fake_numa_create_new_node(((start + size) >> PAGE_SHIFT), &nid);
619                 node_set_online(nid);
620
621                 if (!(size = numa_enforce_memory_limit(start, size))) {
622                         if (--ranges)
623                                 goto new_range;
624                         else
625                                 continue;
626                 }
627
628                 add_active_range(nid, start >> PAGE_SHIFT,
629                                 (start >> PAGE_SHIFT) + (size >> PAGE_SHIFT));
630
631                 if (--ranges)
632                         goto new_range;
633         }
634
635         /*
636          * Now do the same thing for each LMB listed in the ibm,dynamic-memory
637          * property in the ibm,dynamic-reconfiguration-memory node.
638          */
639         memory = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory");
640         if (memory)
641                 parse_drconf_memory(memory);
642
643         return 0;
644 }
645
646 static void __init setup_nonnuma(void)
647 {
648         unsigned long top_of_ram = lmb_end_of_DRAM();
649         unsigned long total_ram = lmb_phys_mem_size();
650         unsigned long start_pfn, end_pfn;
651         unsigned int i, nid = 0;
652
653         printk(KERN_DEBUG "Top of RAM: 0x%lx, Total RAM: 0x%lx\n",
654                top_of_ram, total_ram);
655         printk(KERN_DEBUG "Memory hole size: %ldMB\n",
656                (top_of_ram - total_ram) >> 20);
657
658         for (i = 0; i < lmb.memory.cnt; ++i) {
659                 start_pfn = lmb.memory.region[i].base >> PAGE_SHIFT;
660                 end_pfn = start_pfn + lmb_size_pages(&lmb.memory, i);
661
662                 fake_numa_create_new_node(end_pfn, &nid);
663                 add_active_range(nid, start_pfn, end_pfn);
664                 node_set_online(nid);
665         }
666 }
667
668 void __init dump_numa_cpu_topology(void)
669 {
670         unsigned int node;
671         unsigned int cpu, count;
672
673         if (min_common_depth == -1 || !numa_enabled)
674                 return;
675
676         for_each_online_node(node) {
677                 printk(KERN_DEBUG "Node %d CPUs:", node);
678
679                 count = 0;
680                 /*
681                  * If we used a CPU iterator here we would miss printing
682                  * the holes in the cpumap.
683                  */
684                 for (cpu = 0; cpu < NR_CPUS; cpu++) {
685                         if (cpu_isset(cpu, numa_cpumask_lookup_table[node])) {
686                                 if (count == 0)
687                                         printk(" %u", cpu);
688                                 ++count;
689                         } else {
690                                 if (count > 1)
691                                         printk("-%u", cpu - 1);
692                                 count = 0;
693                         }
694                 }
695
696                 if (count > 1)
697                         printk("-%u", NR_CPUS - 1);
698                 printk("\n");
699         }
700 }
701
702 static void __init dump_numa_memory_topology(void)
703 {
704         unsigned int node;
705         unsigned int count;
706
707         if (min_common_depth == -1 || !numa_enabled)
708                 return;
709
710         for_each_online_node(node) {
711                 unsigned long i;
712
713                 printk(KERN_DEBUG "Node %d Memory:", node);
714
715                 count = 0;
716
717                 for (i = 0; i < lmb_end_of_DRAM();
718                      i += (1 << SECTION_SIZE_BITS)) {
719                         if (early_pfn_to_nid(i >> PAGE_SHIFT) == node) {
720                                 if (count == 0)
721                                         printk(" 0x%lx", i);
722                                 ++count;
723                         } else {
724                                 if (count > 0)
725                                         printk("-0x%lx", i);
726                                 count = 0;
727                         }
728                 }
729
730                 if (count > 0)
731                         printk("-0x%lx", i);
732                 printk("\n");
733         }
734 }
735
736 /*
737  * Allocate some memory, satisfying the lmb or bootmem allocator where
738  * required. nid is the preferred node and end is the physical address of
739  * the highest address in the node.
740  *
741  * Returns the physical address of the memory.
742  */
743 static void __init *careful_allocation(int nid, unsigned long size,
744                                        unsigned long align,
745                                        unsigned long end_pfn)
746 {
747         int new_nid;
748         unsigned long ret = __lmb_alloc_base(size, align, end_pfn << PAGE_SHIFT);
749
750         /* retry over all memory */
751         if (!ret)
752                 ret = __lmb_alloc_base(size, align, lmb_end_of_DRAM());
753
754         if (!ret)
755                 panic("numa.c: cannot allocate %lu bytes on node %d",
756                       size, nid);
757
758         /*
759          * If the memory came from a previously allocated node, we must
760          * retry with the bootmem allocator.
761          */
762         new_nid = early_pfn_to_nid(ret >> PAGE_SHIFT);
763         if (new_nid < nid) {
764                 ret = (unsigned long)__alloc_bootmem_node(NODE_DATA(new_nid),
765                                 size, align, 0);
766
767                 if (!ret)
768                         panic("numa.c: cannot allocate %lu bytes on node %d",
769                               size, new_nid);
770
771                 ret = __pa(ret);
772
773                 dbg("alloc_bootmem %lx %lx\n", ret, size);
774         }
775
776         return (void *)ret;
777 }
778
779 static struct notifier_block __cpuinitdata ppc64_numa_nb = {
780         .notifier_call = cpu_numa_callback,
781         .priority = 1 /* Must run before sched domains notifier. */
782 };
783
784 void __init do_init_bootmem(void)
785 {
786         int nid;
787         unsigned int i;
788
789         min_low_pfn = 0;
790         max_low_pfn = lmb_end_of_DRAM() >> PAGE_SHIFT;
791         max_pfn = max_low_pfn;
792
793         if (parse_numa_properties())
794                 setup_nonnuma();
795         else
796                 dump_numa_memory_topology();
797
798         register_cpu_notifier(&ppc64_numa_nb);
799         cpu_numa_callback(&ppc64_numa_nb, CPU_UP_PREPARE,
800                           (void *)(unsigned long)boot_cpuid);
801
802         for_each_online_node(nid) {
803                 unsigned long start_pfn, end_pfn;
804                 unsigned long bootmem_paddr;
805                 unsigned long bootmap_pages;
806
807                 get_pfn_range_for_nid(nid, &start_pfn, &end_pfn);
808
809                 /* Allocate the node structure node local if possible */
810                 NODE_DATA(nid) = careful_allocation(nid,
811                                         sizeof(struct pglist_data),
812                                         SMP_CACHE_BYTES, end_pfn);
813                 NODE_DATA(nid) = __va(NODE_DATA(nid));
814                 memset(NODE_DATA(nid), 0, sizeof(struct pglist_data));
815
816                 dbg("node %d\n", nid);
817                 dbg("NODE_DATA() = %p\n", NODE_DATA(nid));
818
819                 NODE_DATA(nid)->bdata = &plat_node_bdata[nid];
820                 NODE_DATA(nid)->node_start_pfn = start_pfn;
821                 NODE_DATA(nid)->node_spanned_pages = end_pfn - start_pfn;
822
823                 if (NODE_DATA(nid)->node_spanned_pages == 0)
824                         continue;
825
826                 dbg("start_paddr = %lx\n", start_pfn << PAGE_SHIFT);
827                 dbg("end_paddr = %lx\n", end_pfn << PAGE_SHIFT);
828
829                 bootmap_pages = bootmem_bootmap_pages(end_pfn - start_pfn);
830                 bootmem_paddr = (unsigned long)careful_allocation(nid,
831                                         bootmap_pages << PAGE_SHIFT,
832                                         PAGE_SIZE, end_pfn);
833                 memset(__va(bootmem_paddr), 0, bootmap_pages << PAGE_SHIFT);
834
835                 dbg("bootmap_paddr = %lx\n", bootmem_paddr);
836
837                 init_bootmem_node(NODE_DATA(nid), bootmem_paddr >> PAGE_SHIFT,
838                                   start_pfn, end_pfn);
839
840                 free_bootmem_with_active_regions(nid, end_pfn);
841
842                 /* Mark reserved regions on this node */
843                 for (i = 0; i < lmb.reserved.cnt; i++) {
844                         unsigned long physbase = lmb.reserved.region[i].base;
845                         unsigned long size = lmb.reserved.region[i].size;
846                         unsigned long start_paddr = start_pfn << PAGE_SHIFT;
847                         unsigned long end_paddr = end_pfn << PAGE_SHIFT;
848
849                         if (early_pfn_to_nid(physbase >> PAGE_SHIFT) != nid &&
850                             early_pfn_to_nid((physbase+size-1) >> PAGE_SHIFT) != nid)
851                                 continue;
852
853                         if (physbase < end_paddr &&
854                             (physbase+size) > start_paddr) {
855                                 /* overlaps */
856                                 if (physbase < start_paddr) {
857                                         size -= start_paddr - physbase;
858                                         physbase = start_paddr;
859                                 }
860
861                                 if (size > end_paddr - physbase)
862                                         size = end_paddr - physbase;
863
864                                 dbg("reserve_bootmem %lx %lx\n", physbase,
865                                     size);
866                                 reserve_bootmem_node(NODE_DATA(nid), physbase,
867                                                      size, BOOTMEM_DEFAULT);
868                         }
869                 }
870
871                 sparse_memory_present_with_active_regions(nid);
872         }
873 }
874
875 void __init paging_init(void)
876 {
877         unsigned long max_zone_pfns[MAX_NR_ZONES];
878         memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
879         max_zone_pfns[ZONE_DMA] = lmb_end_of_DRAM() >> PAGE_SHIFT;
880         free_area_init_nodes(max_zone_pfns);
881 }
882
883 static int __init early_numa(char *p)
884 {
885         if (!p)
886                 return 0;
887
888         if (strstr(p, "off"))
889                 numa_enabled = 0;
890
891         if (strstr(p, "debug"))
892                 numa_debug = 1;
893
894         p = strstr(p, "fake=");
895         if (p)
896                 cmdline = p + strlen("fake=");
897
898         return 0;
899 }
900 early_param("numa", early_numa);
901
902 #ifdef CONFIG_MEMORY_HOTPLUG
903 /*
904  * Validate the node associated with the memory section we are
905  * trying to add.
906  */
907 int valid_hot_add_scn(int *nid, unsigned long start, u32 lmb_size,
908                       unsigned long scn_addr)
909 {
910         nodemask_t nodes;
911
912         if (*nid < 0 || !node_online(*nid))
913                 *nid = any_online_node(NODE_MASK_ALL);
914
915         if ((scn_addr >= start) && (scn_addr < (start + lmb_size))) {
916                 nodes_setall(nodes);
917                 while (NODE_DATA(*nid)->node_spanned_pages == 0) {
918                         node_clear(*nid, nodes);
919                         *nid = any_online_node(nodes);
920                 }
921
922                 return 1;
923         }
924
925         return 0;
926 }
927
928 /*
929  * Find the node associated with a hot added memory section represented
930  * by the ibm,dynamic-reconfiguration-memory node.
931  */
932 static int hot_add_drconf_scn_to_nid(struct device_node *memory,
933                                      unsigned long scn_addr)
934 {
935         const u32 *dm;
936         unsigned int n, rc;
937         unsigned long lmb_size;
938         int default_nid = any_online_node(NODE_MASK_ALL);
939         int nid;
940         struct assoc_arrays aa;
941
942         n = of_get_drconf_memory(memory, &dm);
943         if (!n)
944                 return default_nid;;
945
946         lmb_size = of_get_lmb_size(memory);
947         if (!lmb_size)
948                 return default_nid;
949
950         rc = of_get_assoc_arrays(memory, &aa);
951         if (rc)
952                 return default_nid;
953
954         for (; n != 0; --n) {
955                 struct of_drconf_cell drmem;
956
957                 read_drconf_cell(&drmem, &dm);
958
959                 /* skip this block if it is reserved or not assigned to
960                  * this partition */
961                 if ((drmem.flags & DRCONF_MEM_RESERVED)
962                     || !(drmem.flags & DRCONF_MEM_ASSIGNED))
963                         continue;
964
965                 nid = of_drconf_to_nid_single(&drmem, &aa);
966
967                 if (valid_hot_add_scn(&nid, drmem.base_addr, lmb_size,
968                                       scn_addr))
969                         return nid;
970         }
971
972         BUG();  /* section address should be found above */
973         return 0;
974 }
975
976 /*
977  * Find the node associated with a hot added memory section.  Section
978  * corresponds to a SPARSEMEM section, not an LMB.  It is assumed that
979  * sections are fully contained within a single LMB.
980  */
981 int hot_add_scn_to_nid(unsigned long scn_addr)
982 {
983         struct device_node *memory = NULL;
984         int nid;
985
986         if (!numa_enabled || (min_common_depth < 0))
987                 return any_online_node(NODE_MASK_ALL);
988
989         memory = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory");
990         if (memory) {
991                 nid = hot_add_drconf_scn_to_nid(memory, scn_addr);
992                 of_node_put(memory);
993                 return nid;
994         }
995
996         while ((memory = of_find_node_by_type(memory, "memory")) != NULL) {
997                 unsigned long start, size;
998                 int ranges;
999                 const unsigned int *memcell_buf;
1000                 unsigned int len;
1001
1002                 memcell_buf = of_get_property(memory, "reg", &len);
1003                 if (!memcell_buf || len <= 0)
1004                         continue;
1005
1006                 /* ranges in cell */
1007                 ranges = (len >> 2) / (n_mem_addr_cells + n_mem_size_cells);
1008 ha_new_range:
1009                 start = read_n_cells(n_mem_addr_cells, &memcell_buf);
1010                 size = read_n_cells(n_mem_size_cells, &memcell_buf);
1011                 nid = of_node_to_nid_single(memory);
1012
1013                 if (valid_hot_add_scn(&nid, start, size, scn_addr)) {
1014                         of_node_put(memory);
1015                         return nid;
1016                 }
1017
1018                 if (--ranges)           /* process all ranges in cell */
1019                         goto ha_new_range;
1020         }
1021         BUG();  /* section address should be found above */
1022         return 0;
1023 }
1024 #endif /* CONFIG_MEMORY_HOTPLUG */