memblock/tests/alloc_nid_api.c

33 					   phys_addr_t max_addr, int nid)
43 						    max_addr, nid);
46 						  max_addr, nid);
47 	return memblock_alloc_try_nid(size, align, min_addr, max_addr, nid);
52  * max_addr range:
60  *        min_addr           max_addr
62  * Expect to allocate a region that ends at max_addr.
70 	phys_addr_t max_addr;
77 	max_addr = min_addr + SZ_512;
80 					       min_addr, max_addr,
88 	ASSERT_EQ(rgn->base, max_addr - size);
89 	ASSERT_EQ(rgn_end, max_addr);
101  * max_addr range, where the end address is misaligned:
109  *       min_add   |            max_addr
114  * Expect to allocate an aligned region that ends before max_addr.
123 	phys_addr_t max_addr;
130 	max_addr = min_addr + SZ_512 + misalign;
133 					       min_addr, max_addr,
141 	ASSERT_EQ(rgn->base, max_addr - size - misalign);
142 	ASSERT_LT(rgn_end, max_addr);
154  * min_addr and max_addr range:
162  *         min_addr        max_addr
165  * max_addr, given that min_addr is aligned.
173 	phys_addr_t max_addr;
180 	max_addr = min_addr + size;
183 					       min_addr, max_addr,
192 	ASSERT_EQ(rgn_end, max_addr);
204  * min_addr and max_addr range:
212  *           Aligned    |    max_addr
217  * ends at max_addr (if the address is aligned).
225 	phys_addr_t max_addr;
231 	max_addr = min_addr + SMP_CACHE_BYTES;
234 					       min_addr, max_addr,
241 	ASSERT_EQ(rgn->base, max_addr - size);
253  * min_addr and max_addr range, with the latter being too close to the beginning
265  *         |       max_addr
276 	phys_addr_t max_addr;
282 	max_addr = min_addr + SMP_CACHE_BYTES;
285 					       min_addr, max_addr,
305  *          min_addr                 max_addr
317 	phys_addr_t max_addr;
323 	max_addr = memblock_end_of_DRAM();
324 	min_addr = max_addr - r2_size;
330 					       min_addr, max_addr,
348  * A test that tries to allocate a memory region within min_addr and max_addr,
349  * with max_addr being so close that it's next to an allocated region:
357  *             min_addr      max_addr
369 	phys_addr_t max_addr;
374 	max_addr = memblock_end_of_DRAM() - r1_size;
375 	min_addr = max_addr - r2_size;
377 	memblock_reserve(max_addr, r1_size);
380 					       min_addr, max_addr,
408  *                min_addr    max_addr
423 	phys_addr_t max_addr;
437 	max_addr = r1.base;
443 					       min_addr, max_addr,
450 	ASSERT_EQ(rgn1->base, max_addr - r3_size);
474  *                 min_addr max_addr
486 	phys_addr_t max_addr;
500 	max_addr = r1.base;
506 					       min_addr, max_addr,
534  *                       |    max_addr
550 	phys_addr_t max_addr;
564 	max_addr = r1.base;
570 					       min_addr, max_addr,
603  *                 |      max_addr
616 	phys_addr_t max_addr;
629 	max_addr = r1.base;
635 					       min_addr, max_addr,
646  * A test that tries to allocate a memory region, where max_addr is
656 	phys_addr_t max_addr;
662 	max_addr = memblock_end_of_DRAM() + SZ_256;
665 					       min_addr, max_addr,
693 	phys_addr_t max_addr;
699 	max_addr = memblock_end_of_DRAM();
702 					       min_addr, max_addr,
721  * max_addr range:
729  *        min_addr                max_addr
731  * Expect to allocate a region that ends before max_addr.
739 	phys_addr_t max_addr;
746 	max_addr = min_addr + SZ_512;
749 					       min_addr, max_addr,
758 	ASSERT_LT(rgn_end, max_addr);
770  * max_addr range, where the start address is misaligned:
778  *     min_add     |            max_addr
783  * Expect to allocate an aligned region that ends before max_addr.
792 	phys_addr_t max_addr;
799 	max_addr = min_addr + SZ_512;
802 					       min_addr, max_addr,
811 	ASSERT_LT(rgn_end, max_addr);
823  * and max_addr range:
831  *                      |    max_addr
844 	phys_addr_t max_addr;
850 	max_addr = min_addr + SMP_CACHE_BYTES;
853 					       min_addr, max_addr,
881  *                min_addr    max_addr
896 	phys_addr_t max_addr;
910 	max_addr = r1.base;
916 					       min_addr, max_addr,
923 	ASSERT_EQ(rgn1->base, max_addr);
947  *                         |  max_addr
966 	phys_addr_t max_addr;
980 	max_addr = r1.base;
986 					       min_addr, max_addr,
1010  * A test that tries to allocate a memory region, where max_addr is
1020 	phys_addr_t max_addr;
1026 	max_addr = memblock_end_of_DRAM() + SZ_256;
1029 					       min_addr, max_addr,
1057 	phys_addr_t max_addr;
1063 	max_addr = memblock_end_of_DRAM() - SZ_256;
1066 					       min_addr, max_addr,
1251 	phys_addr_t max_addr;
1259 	max_addr = memblock_end_of_DRAM();
1262 					       min_addr, max_addr, nid_req);
1304 	phys_addr_t max_addr;
1311 	max_addr = memblock_end_of_DRAM();
1314 					       min_addr, max_addr, nid_req);
1357 	phys_addr_t max_addr;
1364 	max_addr = memblock_end_of_DRAM();
1368 					       min_addr, max_addr, nid_req);
1409 	phys_addr_t max_addr;
1419 	max_addr = memblock_end_of_DRAM();
1423 					       min_addr, max_addr, nid_req);
1469 	phys_addr_t max_addr;
1480 	max_addr = memblock_end_of_DRAM();
1484 					       min_addr, max_addr, nid_req);
1503  * and max_addr range and overlaps with two different nodes, where the first
1507  *                                |           max_addr
1529 	phys_addr_t max_addr;
1537 	max_addr = min_addr + size;
1540 					       min_addr, max_addr, nid_req);
1559  * and max_addr range and overlaps with two different nodes, where the second
1563  *                               |         max_addr
1586 	phys_addr_t max_addr;
1594 	max_addr = min_addr + size;
1597 					       min_addr, max_addr, nid_req);
1616  * and max_addr range and overlaps with two different nodes, where the requested
1620  *                                         |         max_addr
1643 	phys_addr_t max_addr;
1650 	max_addr = min_addr + size;
1653 					       min_addr, max_addr, nid_req);
1677  *                          |                                 max_addr
1699 	phys_addr_t max_addr;
1706 	max_addr = region_end(max_node);
1709 					       min_addr, max_addr, nid_req);
1715 	ASSERT_EQ(new_rgn->base, max_addr - size);
1729  * after max_addr. The range overlaps with multiple nodes along node
1733  *        |                                 max_addr
1755 	phys_addr_t max_addr;
1762 	max_addr = region_end(max_node);
1765 					       min_addr, max_addr, nid_req);
1771 	ASSERT_EQ(new_rgn->base, max_addr - size);
1795 	phys_addr_t max_addr;
1803 	max_addr = memblock_end_of_DRAM();
1806 					       min_addr, max_addr, nid_req);
1848 	phys_addr_t max_addr;
1855 	max_addr = memblock_end_of_DRAM();
1858 					       min_addr, max_addr, nid_req);
1902 	phys_addr_t max_addr;
1909 	max_addr = memblock_end_of_DRAM();
1913 					       min_addr, max_addr, nid_req);
1954 	phys_addr_t max_addr;
1965 	max_addr = memblock_end_of_DRAM();
1970 					       min_addr, max_addr, nid_req);
2016 	phys_addr_t max_addr;
2027 	max_addr = memblock_end_of_DRAM();
2031 					       min_addr, max_addr, nid_req);
2050  * and max_addr range and overlaps with two different nodes, where the first
2054  *                                |           max_addr
2076 	phys_addr_t max_addr;
2084 	max_addr = min_addr + size;
2087 					       min_addr, max_addr, nid_req);
2106  * and max_addr range and overlaps with two different nodes, where the second
2110  *                                                |         max_addr
2134 	phys_addr_t max_addr;
2142 	max_addr = min_addr + size;
2145 					       min_addr, max_addr, nid_req);
2164  * and max_addr range and overlaps with two different nodes, where the requested
2168  *                                         |         max_addr
2191 	phys_addr_t max_addr;
2198 	max_addr = min_addr + size;
2201 					       min_addr, max_addr, nid_req);
2225  *                          |                                 max_addr
2247 	phys_addr_t max_addr;
2254 	max_addr = region_end(max_node);
2257 					       min_addr, max_addr, nid_req);
2277  * after max_addr. The range overlaps with multiple nodes along node
2281  *        |                                 max_addr
2303 	phys_addr_t max_addr;
2310 	max_addr = region_end(max_node);
2313 					       min_addr, max_addr, nid_req);
2350 	phys_addr_t max_addr;
2356 	max_addr = memblock_end_of_DRAM();
2359 					       min_addr, max_addr, nid_req);
2368  * A test that tries to allocate memory within min_addr and max_addr range when
2370  * min_addr and ends at max_addr and is the same size as the region to be
2374  *                     |                       max_addr
2399 	phys_addr_t max_addr;
2413 	max_addr = r1.base;
2419 					       min_addr, max_addr, nid_req);
2456  *                         |           max_addr
2468 	phys_addr_t max_addr;
2481 	max_addr = r2.base;
2487 					       min_addr, max_addr,