2 * Some of the code in this file has been gleaned from the 64 bit
3 * discontigmem support code base.
5 * Copyright (C) 2002, IBM Corp.
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
17 * NON INFRINGEMENT. See the GNU General Public License for more
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 * Send feedback to Pat Gaughen <gone@us.ibm.com>
26 #include <linux/config.h>
28 #include <linux/bootmem.h>
29 #include <linux/mmzone.h>
30 #include <linux/acpi.h>
31 #include <linux/nodemask.h>
33 #include <asm/topology.h>
36 * proximity macros and definitions
38 #define NODE_ARRAY_INDEX(x) ((x) / 8) /* 8 bits/char */
39 #define NODE_ARRAY_OFFSET(x) ((x) % 8) /* 8 bits/char */
40 #define BMAP_SET(bmap, bit) ((bmap)[NODE_ARRAY_INDEX(bit)] |= 1 << NODE_ARRAY_OFFSET(bit))
41 #define BMAP_TEST(bmap, bit) ((bmap)[NODE_ARRAY_INDEX(bit)] & (1 << NODE_ARRAY_OFFSET(bit)))
42 /* bitmap length; _PXM is at most 255 */
43 #define PXM_BITMAP_LEN (MAX_PXM_DOMAINS / 8)
44 static u8 pxm_bitmap
[PXM_BITMAP_LEN
]; /* bitmap of proximity domains */
46 #define MAX_CHUNKS_PER_NODE 4
47 #define MAXCHUNKS (MAX_CHUNKS_PER_NODE * MAX_NUMNODES)
48 struct node_memory_chunk_s
{
49 unsigned long start_pfn
;
50 unsigned long end_pfn
;
51 u8 pxm
; // proximity domain of node
52 u8 nid
; // which cnode contains this chunk?
53 u8 bank
; // which mem bank on this node
55 static struct node_memory_chunk_s node_memory_chunk
[MAXCHUNKS
];
57 static int num_memory_chunks
; /* total number of memory chunks */
58 static int zholes_size_init
;
59 static unsigned long zholes_size
[MAX_NUMNODES
* MAX_NR_ZONES
];
61 extern void * boot_ioremap(unsigned long, unsigned long);
63 /* Identify CPU proximity domains */
64 static void __init
parse_cpu_affinity_structure(char *p
)
66 struct acpi_table_processor_affinity
*cpu_affinity
=
67 (struct acpi_table_processor_affinity
*) p
;
69 if (!cpu_affinity
->flags
.enabled
)
70 return; /* empty entry */
72 /* mark this node as "seen" in node bitmap */
73 BMAP_SET(pxm_bitmap
, cpu_affinity
->proximity_domain
);
75 printk("CPU 0x%02X in proximity domain 0x%02X\n",
76 cpu_affinity
->apic_id
, cpu_affinity
->proximity_domain
);
80 * Identify memory proximity domains and hot-remove capabilities.
81 * Fill node memory chunk list structure.
83 static void __init
parse_memory_affinity_structure (char *sratp
)
85 unsigned long long paddr
, size
;
86 unsigned long start_pfn
, end_pfn
;
88 struct node_memory_chunk_s
*p
, *q
, *pend
;
89 struct acpi_table_memory_affinity
*memory_affinity
=
90 (struct acpi_table_memory_affinity
*) sratp
;
92 if (!memory_affinity
->flags
.enabled
)
93 return; /* empty entry */
95 /* mark this node as "seen" in node bitmap */
96 BMAP_SET(pxm_bitmap
, memory_affinity
->proximity_domain
);
98 /* calculate info for memory chunk structure */
99 paddr
= memory_affinity
->base_addr_hi
;
100 paddr
= (paddr
<< 32) | memory_affinity
->base_addr_lo
;
101 size
= memory_affinity
->length_hi
;
102 size
= (size
<< 32) | memory_affinity
->length_lo
;
104 start_pfn
= paddr
>> PAGE_SHIFT
;
105 end_pfn
= (paddr
+ size
) >> PAGE_SHIFT
;
107 pxm
= memory_affinity
->proximity_domain
;
109 if (num_memory_chunks
>= MAXCHUNKS
) {
110 printk("Too many mem chunks in SRAT. Ignoring %lld MBytes at %llx\n",
111 size
/(1024*1024), paddr
);
115 /* Insertion sort based on base address */
116 pend
= &node_memory_chunk
[num_memory_chunks
];
117 for (p
= &node_memory_chunk
[0]; p
< pend
; p
++) {
118 if (start_pfn
< p
->start_pfn
)
122 for (q
= pend
; q
>= p
; q
--)
125 p
->start_pfn
= start_pfn
;
126 p
->end_pfn
= end_pfn
;
131 printk("Memory range 0x%lX to 0x%lX (type 0x%X) in proximity domain 0x%02X %s\n",
133 memory_affinity
->memory_type
,
134 memory_affinity
->proximity_domain
,
135 (memory_affinity
->flags
.hot_pluggable
?
136 "enabled and removable" : "enabled" ) );
139 #if MAX_NR_ZONES != 4
140 #error "MAX_NR_ZONES != 4, chunk_to_zone requires review"
142 /* Take a chunk of pages from page frame cstart to cend and count the number
143 * of pages in each zone, returned via zones[].
145 static __init
void chunk_to_zones(unsigned long cstart
, unsigned long cend
,
146 unsigned long *zones
)
148 unsigned long max_dma
;
149 extern unsigned long max_low_pfn
;
154 /* FIXME: MAX_DMA_ADDRESS and max_low_pfn are trying to provide
155 * similarly scoped information and should be handled in a consistant
158 max_dma
= virt_to_phys((char *)MAX_DMA_ADDRESS
) >> PAGE_SHIFT
;
160 /* Split the hole into the zones in which it falls. Repeatedly
161 * take the segment in which the remaining hole starts, round it
162 * to the end of that zone.
164 memset(zones
, 0, MAX_NR_ZONES
* sizeof(long));
165 while (cstart
< cend
) {
166 if (cstart
< max_dma
) {
168 rend
= (cend
< max_dma
)? cend
: max_dma
;
170 } else if (cstart
< max_low_pfn
) {
172 rend
= (cend
< max_low_pfn
)? cend
: max_low_pfn
;
178 zones
[z
] += rend
- cstart
;
184 * The SRAT table always lists ascending addresses, so can always
185 * assume that the first "start" address that you see is the real
186 * start of the node, and that the current "end" address is after
189 static __init
void node_read_chunk(int nid
, struct node_memory_chunk_s
*memory_chunk
)
192 * Only add present memory as told by the e820.
193 * There is no guarantee from the SRAT that the memory it
194 * enumerates is present at boot time because it represents
195 * *possible* memory hotplug areas the same as normal RAM.
197 if (memory_chunk
->start_pfn
>= max_pfn
) {
198 printk (KERN_INFO
"Ignoring SRAT pfns: 0x%08lx -> %08lx\n",
199 memory_chunk
->start_pfn
, memory_chunk
->end_pfn
);
202 if (memory_chunk
->nid
!= nid
)
205 if (!node_has_online_mem(nid
))
206 node_start_pfn
[nid
] = memory_chunk
->start_pfn
;
208 if (node_start_pfn
[nid
] > memory_chunk
->start_pfn
)
209 node_start_pfn
[nid
] = memory_chunk
->start_pfn
;
211 if (node_end_pfn
[nid
] < memory_chunk
->end_pfn
)
212 node_end_pfn
[nid
] = memory_chunk
->end_pfn
;
215 /* Parse the ACPI Static Resource Affinity Table */
216 static int __init
acpi20_parse_srat(struct acpi_table_srat
*sratp
)
221 start
= (u8
*)(&(sratp
->reserved
) + 1); /* skip header */
223 end
= (u8
*)sratp
+ sratp
->header
.length
;
225 memset(pxm_bitmap
, 0, sizeof(pxm_bitmap
)); /* init proximity domain bitmap */
226 memset(node_memory_chunk
, 0, sizeof(node_memory_chunk
));
227 memset(zholes_size
, 0, sizeof(zholes_size
));
229 num_memory_chunks
= 0;
232 case ACPI_SRAT_PROCESSOR_AFFINITY
:
233 parse_cpu_affinity_structure(p
);
235 case ACPI_SRAT_MEMORY_AFFINITY
:
236 parse_memory_affinity_structure(p
);
239 printk("ACPI 2.0 SRAT: unknown entry skipped: type=0x%02X, len=%d\n", p
[0], p
[1]);
244 printk("acpi20_parse_srat: Entry length value is zero;"
245 " can't parse any further!\n");
250 if (num_memory_chunks
== 0) {
251 printk("could not finy any ACPI SRAT memory areas.\n");
255 /* Calculate total number of nodes in system from PXM bitmap and create
256 * a set of sequential node IDs starting at zero. (ACPI doesn't seem
257 * to specify the range of _PXM values.)
260 * MCD - we no longer HAVE to number nodes sequentially. PXM domain
261 * numbers could go as high as 256, and MAX_NUMNODES for i386 is typically
262 * 32, so we will continue numbering them in this manner until MAX_NUMNODES
263 * approaches MAX_PXM_DOMAINS for i386.
265 nodes_clear(node_online_map
);
266 for (i
= 0; i
< MAX_PXM_DOMAINS
; i
++) {
267 if (BMAP_TEST(pxm_bitmap
, i
)) {
268 int nid
= acpi_map_pxm_to_node(i
);
269 node_set_online(nid
);
272 BUG_ON(num_online_nodes() == 0);
274 /* set cnode id in memory chunk structure */
275 for (i
= 0; i
< num_memory_chunks
; i
++)
276 node_memory_chunk
[i
].nid
= pxm_to_node(node_memory_chunk
[i
].pxm
);
278 printk("pxm bitmap: ");
279 for (i
= 0; i
< sizeof(pxm_bitmap
); i
++) {
280 printk("%02X ", pxm_bitmap
[i
]);
283 printk("Number of logical nodes in system = %d\n", num_online_nodes());
284 printk("Number of memory chunks in system = %d\n", num_memory_chunks
);
286 for (j
= 0; j
< num_memory_chunks
; j
++){
287 struct node_memory_chunk_s
* chunk
= &node_memory_chunk
[j
];
288 printk("chunk %d nid %d start_pfn %08lx end_pfn %08lx\n",
289 j
, chunk
->nid
, chunk
->start_pfn
, chunk
->end_pfn
);
290 node_read_chunk(chunk
->nid
, chunk
);
293 for_each_online_node(nid
) {
294 unsigned long start
= node_start_pfn
[nid
];
295 unsigned long end
= node_end_pfn
[nid
];
297 memory_present(nid
, start
, end
);
298 node_remap_size
[nid
] = node_memmap_size_bytes(nid
, start
, end
);
305 int __init
get_memcfg_from_srat(void)
307 struct acpi_table_header
*header
= NULL
;
308 struct acpi_table_rsdp
*rsdp
= NULL
;
309 struct acpi_table_rsdt
*rsdt
= NULL
;
310 struct acpi_pointer
*rsdp_address
= NULL
;
311 struct acpi_table_rsdt saved_rsdt
;
315 if (ACPI_FAILURE(acpi_find_root_pointer(ACPI_PHYSICAL_ADDRESSING
,
317 printk("%s: System description tables not found\n",
322 if (rsdp_address
->pointer_type
== ACPI_PHYSICAL_POINTER
) {
323 printk("%s: assigning address to rsdp\n", __FUNCTION__
);
324 rsdp
= (struct acpi_table_rsdp
*)
325 (u32
)rsdp_address
->pointer
.physical
;
327 printk("%s: rsdp_address is not a physical pointer\n", __FUNCTION__
);
331 printk("%s: Didn't find ACPI root!\n", __FUNCTION__
);
335 printk(KERN_INFO
"%.8s v%d [%.6s]\n", rsdp
->signature
, rsdp
->revision
,
338 if (strncmp(rsdp
->signature
, RSDP_SIG
,strlen(RSDP_SIG
))) {
339 printk(KERN_WARNING
"%s: RSDP table signature incorrect\n", __FUNCTION__
);
343 rsdt
= (struct acpi_table_rsdt
*)
344 boot_ioremap(rsdp
->rsdt_address
, sizeof(struct acpi_table_rsdt
));
348 "%s: ACPI: Invalid root system description tables (RSDT)\n",
353 header
= & rsdt
->header
;
355 if (strncmp(header
->signature
, RSDT_SIG
, strlen(RSDT_SIG
))) {
356 printk(KERN_WARNING
"ACPI: RSDT signature incorrect\n");
361 * The number of tables is computed by taking the
362 * size of all entries (header size minus total
363 * size of RSDT) divided by the size of each entry
364 * (4-byte table pointers).
366 tables
= (header
->length
- sizeof(struct acpi_table_header
)) / 4;
371 memcpy(&saved_rsdt
, rsdt
, sizeof(saved_rsdt
));
373 if (saved_rsdt
.header
.length
> sizeof(saved_rsdt
)) {
374 printk(KERN_WARNING
"ACPI: Too big length in RSDT: %d\n",
375 saved_rsdt
.header
.length
);
379 printk("Begin SRAT table scan....\n");
381 for (i
= 0; i
< tables
; i
++) {
382 /* Map in header, then map in full table length. */
383 header
= (struct acpi_table_header
*)
384 boot_ioremap(saved_rsdt
.entry
[i
], sizeof(struct acpi_table_header
));
387 header
= (struct acpi_table_header
*)
388 boot_ioremap(saved_rsdt
.entry
[i
], header
->length
);
392 if (strncmp((char *) &header
->signature
, "SRAT", 4))
395 /* we've found the srat table. don't need to look at any more tables */
396 return acpi20_parse_srat((struct acpi_table_srat
*)header
);
399 printk("failed to get NUMA memory information from SRAT table\n");
403 /* For each node run the memory list to determine whether there are
404 * any memory holes. For each hole determine which ZONE they fall
407 * NOTE#1: this requires knowledge of the zone boundries and so
408 * _cannot_ be performed before those are calculated in setup_memory.
410 * NOTE#2: we rely on the fact that the memory chunks are ordered by
411 * start pfn number during setup.
413 static void __init
get_zholes_init(void)
418 unsigned long end
= 0;
420 for_each_online_node(nid
) {
422 for (c
= 0; c
< num_memory_chunks
; c
++){
423 if (node_memory_chunk
[c
].nid
== nid
) {
425 end
= node_memory_chunk
[c
].end_pfn
;
429 /* Record any gap between this chunk
430 * and the previous chunk on this node
431 * against the zones it spans.
434 node_memory_chunk
[c
].start_pfn
,
435 &zholes_size
[nid
* MAX_NR_ZONES
]);
442 unsigned long * __init
get_zholes_size(int nid
)
444 if (!zholes_size_init
) {
448 if (nid
>= MAX_NUMNODES
|| !node_online(nid
))
449 printk("%s: nid = %d is invalid/offline. num_online_nodes = %d",
450 __FUNCTION__
, nid
, num_online_nodes());
451 return &zholes_size
[nid
* MAX_NR_ZONES
];