Whitebox
/
u-boot
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Change lmb to use phys_size_t/phys_addr_t

Browse Source 
This updates the lmb code to use phys_size_t
and phys_addr_t instead of unsigned long.  Other code
which interacts with this code, like getenv_bootm_size()
is also updated.

Booted on MPC8641HPCN, build-tested ppc, arm, mips.

Signed-off-by: Becky Bruce <becky.bruce@freescale.com>
master
Becky Bruce 17 years ago committed by Wolfgang Denk
parent 61b09fc295
commit 391fd93ab2
6 changed files with 71 additions and 60 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 5
      common/cmd_bootm.c
  2. 17
      common/image.c
  3. 2
      include/image.h
  4. 22
      include/lmb.h
  5. 69
      lib_generic/lmb.c
  6. 16
      lib_ppc/bootm.c

5
common/cmd_bootm.c
Unescape View File

@ -127,7 +127,8 @@ int do_bootm (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
ulong os_data, os_len;
ulong image_start, image_end;
ulong load_start, load_end;
ulong mem_start, mem_size;
ulong mem_start;
phys_size_t mem_size;
struct lmb lmb;
@ -141,7 +142,7 @@ int do_bootm (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
mem_start = getenv_bootm_low();
mem_size = getenv_bootm_size();
lmb_add(&lmb, mem_start, mem_size);
lmb_add(&lmb, (phys_addr_t)mem_start, mem_size);
board_lmb_reserve(&lmb);

17
common/image.c
Unescape View File

@ -435,11 +435,16 @@ ulong getenv_bootm_low(void)
#endif
}
ulong getenv_bootm_size(void)
phys_size_t getenv_bootm_size(void)
{
char *s = getenv ("bootm_size");
if (s) {
ulong tmp = simple_strtoul (s, NULL, 16);
phys_size_t tmp;
#ifdef CFG_64BIT_STRTOUL
tmp = (phys_size_t)simple_strtoull (s, NULL, 16);
#else
tmp = (phys_size_t)simple_strtoul (s, NULL, 16);
#endif
return tmp;
}
@ -1034,9 +1039,9 @@ int boot_ramdisk_high (struct lmb *lmb, ulong rd_data, ulong rd_len,
lmb_reserve(lmb, rd_data, rd_len);
} else {
if (initrd_high)
*initrd_start = lmb_alloc_base (lmb, rd_len, 0x1000, initrd_high);
*initrd_start = (ulong)lmb_alloc_base (lmb, rd_len, 0x1000, initrd_high);
else
*initrd_start = lmb_alloc (lmb, rd_len, 0x1000);
*initrd_start = (ulong)lmb_alloc (lmb, rd_len, 0x1000);
if (*initrd_start == 0) {
puts ("ramdisk - allocation error\n");
@ -1089,7 +1094,7 @@ int boot_get_cmdline (struct lmb *lmb, ulong *cmd_start, ulong *cmd_end,
char *cmdline;
char *s;
cmdline = (char *)lmb_alloc_base(lmb, CFG_BARGSIZE, 0xf,
cmdline = (char *)(ulong)lmb_alloc_base(lmb, CFG_BARGSIZE, 0xf,
CFG_BOOTMAPSZ + bootmap_base);
if (cmdline == NULL)
@ -1125,7 +1130,7 @@ int boot_get_cmdline (struct lmb *lmb, ulong *cmd_start, ulong *cmd_end,
*/
int boot_get_kbd (struct lmb *lmb, bd_t **kbd, ulong bootmap_base)
{
*kbd = (bd_t *)lmb_alloc_base(lmb, sizeof(bd_t), 0xf,
*kbd = (bd_t *)(ulong)lmb_alloc_base(lmb, sizeof(bd_t), 0xf,
CFG_BOOTMAPSZ + bootmap_base);
if (*kbd == NULL)
return -1;

2
include/image.h
Unescape View File

@ -379,7 +379,7 @@ int image_check_dcrc (image_header_t *hdr);
#ifndef USE_HOSTCC
int getenv_yesno (char *var);
ulong getenv_bootm_low(void);
ulong getenv_bootm_size(void);
phys_size_t getenv_bootm_size(void);
void memmove_wd (void *to, void *from, size_t len, ulong chunksz);
#endif

22
include/lmb.h
Unescape View File

@ -17,13 +17,13 @@
#define MAX_LMB_REGIONS 8
struct lmb_property {
ulong base;
ulong size;
phys_addr_t base;
phys_size_t size;
};
struct lmb_region {
unsigned long cnt;
ulong size;
phys_size_t size;
struct lmb_property region[MAX_LMB_REGIONS+1];
};
@ -35,16 +35,18 @@ struct lmb {
extern struct lmb lmb;
extern void lmb_init(struct lmb *lmb);
extern long lmb_add(struct lmb *lmb, ulong base, ulong size);
extern long lmb_reserve(struct lmb *lmb, ulong base, ulong size);
extern ulong lmb_alloc(struct lmb *lmb, ulong size, ulong align);
extern ulong lmb_alloc_base(struct lmb *lmb, ulong size, ulong align, ulong max_addr);
extern ulong __lmb_alloc_base(struct lmb *lmb, ulong size, ulong align, ulong max_addr);
extern int lmb_is_reserved(struct lmb *lmb, ulong addr);
extern long lmb_add(struct lmb *lmb, phys_addr_t base, phys_size_t size);
extern long lmb_reserve(struct lmb *lmb, phys_addr_t base, phys_size_t size);
extern phys_addr_t lmb_alloc(struct lmb *lmb, phys_size_t size, ulong align);
extern phys_addr_t lmb_alloc_base(struct lmb *lmb, phys_size_t size, ulong align,
phys_addr_t max_addr);
extern phys_addr_t __lmb_alloc_base(struct lmb *lmb, phys_size_t size, ulong align,
phys_addr_t max_addr);
extern int lmb_is_reserved(struct lmb *lmb, phys_addr_t addr);
extern void lmb_dump_all(struct lmb *lmb);
static inline ulong
static inline phys_size_t
lmb_size_bytes(struct lmb_region *type, unsigned long region_nr)
{
return type->region[region_nr].size;

69
lib_generic/lmb.c
Unescape View File

@ -22,33 +22,34 @@ void lmb_dump_all(struct lmb *lmb)
debug("lmb_dump_all:\n");
debug(" memory.cnt = 0x%lx\n", lmb->memory.cnt);
debug(" memory.size = 0x%08x\n", lmb->memory.size);
debug(" memory.size = 0x%llx\n",
(unsigned long long)lmb->memory.size);
for (i=0; i < lmb->memory.cnt ;i++) {
debug(" memory.reg[0x%x].base = 0x%08x\n", i,
debug(" memory.reg[0x%x].base = 0x%llx\n", i,
lmb->memory.region[i].base);
debug(" .size = 0x%08x\n",
debug(" .size = 0x%llx\n",
lmb->memory.region[i].size);
}
debug("\n reserved.cnt = 0x%lx\n", lmb->reserved.cnt);
debug(" reserved.size = 0x%08x\n", lmb->reserved.size);
debug(" reserved.size = 0x%llx\n", lmb->reserved.size);
for (i=0; i < lmb->reserved.cnt ;i++) {
debug(" reserved.reg[0x%x].base = 0x%08x\n", i,
debug(" reserved.reg[0x%x].base = 0x%llx\n", i,
lmb->reserved.region[i].base);
debug(" .size = 0x%08x\n",
debug(" .size = 0x%llx\n",
lmb->reserved.region[i].size);
}
#endif /* DEBUG */
}
static unsigned long lmb_addrs_overlap(ulong base1,
ulong size1, ulong base2, ulong size2)
static long lmb_addrs_overlap(phys_addr_t base1,
phys_size_t size1, phys_addr_t base2, phys_size_t size2)
{
return ((base1 < (base2+size2)) && (base2 < (base1+size1)));
}
static long lmb_addrs_adjacent(ulong base1, ulong size1,
ulong base2, ulong size2)
static long lmb_addrs_adjacent(phys_addr_t base1, phys_size_t size1,
phys_addr_t base2, phys_size_t size2)
{
if (base2 == base1 + size1)
return 1;
@ -61,10 +62,10 @@ static long lmb_addrs_adjacent(ulong base1, ulong size1,
static long lmb_regions_adjacent(struct lmb_region *rgn,
unsigned long r1, unsigned long r2)
{
ulong base1 = rgn->region[r1].base;
ulong size1 = rgn->region[r1].size;
ulong base2 = rgn->region[r2].base;
ulong size2 = rgn->region[r2].size;
phys_addr_t base1 = rgn->region[r1].base;
phys_size_t size1 = rgn->region[r1].size;
phys_addr_t base2 = rgn->region[r2].base;
phys_size_t size2 = rgn->region[r2].size;
return lmb_addrs_adjacent(base1, size1, base2, size2);
}
@ -106,7 +107,7 @@ void lmb_init(struct lmb *lmb)
}
/* This routine called with relocation disabled. */
static long lmb_add_region(struct lmb_region *rgn, ulong base, ulong size)
static long lmb_add_region(struct lmb_region *rgn, phys_addr_t base, phys_size_t size)
{
unsigned long coalesced = 0;
long adjacent, i;
@ -119,8 +120,8 @@ static long lmb_add_region(struct lmb_region *rgn, ulong base, ulong size)
/* First try and coalesce this LMB with another. */
for (i=0; i < rgn->cnt; i++) {
ulong rgnbase = rgn->region[i].base;
ulong rgnsize = rgn->region[i].size;
phys_addr_t rgnbase = rgn->region[i].base;
phys_size_t rgnsize = rgn->region[i].size;
if ((rgnbase == base) && (rgnsize == size))
/* Already have this region, so we're done */
@ -173,28 +174,28 @@ static long lmb_add_region(struct lmb_region *rgn, ulong base, ulong size)
}
/* This routine may be called with relocation disabled. */
long lmb_add(struct lmb *lmb, ulong base, ulong size)
long lmb_add(struct lmb *lmb, phys_addr_t base, phys_size_t size)
{
struct lmb_region *_rgn = &(lmb->memory);
return lmb_add_region(_rgn, base, size);
}
long lmb_reserve(struct lmb *lmb, ulong base, ulong size)
long lmb_reserve(struct lmb *lmb, phys_addr_t base, phys_size_t size)
{
struct lmb_region *_rgn = &(lmb->reserved);
return lmb_add_region(_rgn, base, size);
}
long lmb_overlaps_region(struct lmb_region *rgn, ulong base,
ulong size)
long lmb_overlaps_region(struct lmb_region *rgn, phys_addr_t base,
phys_size_t size)
{
unsigned long i;
for (i=0; i < rgn->cnt; i++) {
ulong rgnbase = rgn->region[i].base;
ulong rgnsize = rgn->region[i].size;
phys_addr_t rgnbase = rgn->region[i].base;
phys_size_t rgnsize = rgn->region[i].size;
if ( lmb_addrs_overlap(base,size,rgnbase,rgnsize) ) {
break;
}
@ -203,14 +204,14 @@ long lmb_overlaps_region(struct lmb_region *rgn, ulong base,
return (i < rgn->cnt) ? i : -1;
}
ulong lmb_alloc(struct lmb *lmb, ulong size, ulong align)
phys_addr_t lmb_alloc(struct lmb *lmb, phys_size_t size, ulong align)
{
return lmb_alloc_base(lmb, size, align, LMB_ALLOC_ANYWHERE);
}
ulong lmb_alloc_base(struct lmb *lmb, ulong size, ulong align, ulong max_addr)
phys_addr_t lmb_alloc_base(struct lmb *lmb, phys_size_t size, ulong align, phys_addr_t max_addr)
{
ulong alloc;
phys_addr_t alloc;
alloc = __lmb_alloc_base(lmb, size, align, max_addr);
@ -221,24 +222,24 @@ ulong lmb_alloc_base(struct lmb *lmb, ulong size, ulong align, ulong max_addr)
return alloc;
}
static ulong lmb_align_down(ulong addr, ulong size)
static phys_addr_t lmb_align_down(phys_addr_t addr, phys_size_t size)
{
return addr & ~(size - 1);
}
static ulong lmb_align_up(ulong addr, ulong size)
static phys_addr_t lmb_align_up(phys_addr_t addr, ulong size)
{
return (addr + (size - 1)) & ~(size - 1);
}
ulong __lmb_alloc_base(struct lmb *lmb, ulong size, ulong align, ulong max_addr)
phys_addr_t __lmb_alloc_base(struct lmb *lmb, phys_size_t size, ulong align, phys_addr_t max_addr)
{
long i, j;
ulong base = 0;
phys_addr_t base = 0;
for (i = lmb->memory.cnt-1; i >= 0; i--) {
ulong lmbbase = lmb->memory.region[i].base;
ulong lmbsize = lmb->memory.region[i].size;
phys_addr_t lmbbase = lmb->memory.region[i].base;
phys_size_t lmbsize = lmb->memory.region[i].size;
if (max_addr == LMB_ALLOC_ANYWHERE)
base = lmb_align_down(lmbbase + lmbsize - size, align);
@ -266,12 +267,12 @@ ulong __lmb_alloc_base(struct lmb *lmb, ulong size, ulong align, ulong max_addr)
return base;
}
int lmb_is_reserved(struct lmb *lmb, ulong addr)
int lmb_is_reserved(struct lmb *lmb, phys_addr_t addr)
{
int i;
for (i = 0; i < lmb->reserved.cnt; i++) {
ulong upper = lmb->reserved.region[i].base +
phys_addr_t upper = lmb->reserved.region[i].base +
lmb->reserved.region[i].size - 1;
if ((addr >= lmb->reserved.region[i].base) && (addr <= upper))
return 1;

16
lib_ppc/bootm.c
Unescape View File

@ -71,6 +71,7 @@ do_bootm_linux(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[],
ulong initrd_start, initrd_end;
ulong rd_data_start, rd_data_end, rd_len;
ulong size;
phys_size_t bootm_size;
ulong cmd_start, cmd_end, bootmap_base;
bd_t *kbd;
@ -85,22 +86,23 @@ do_bootm_linux(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[],
#endif
bootmap_base = getenv_bootm_low();
size = getenv_bootm_size();
bootm_size = getenv_bootm_size();
#ifdef DEBUG
if (((u64)bootmap_base + size) > (CFG_SDRAM_BASE + (u64)gd->ram_size))
if (((u64)bootmap_base + bootm_size) >
(CFG_SDRAM_BASE + (u64)gd->ram_size))
puts("WARNING: bootm_low + bootm_size exceed total memory\n");
if ((bootmap_base + size) > get_effective_memsize())
if ((bootmap_base + bootm_size) > get_effective_memsize())
puts("WARNING: bootm_low + bootm_size exceed eff. memory\n");
#endif
size = min(size, get_effective_memsize());
size = min(bootm_size, get_effective_memsize());
size = min(size, CFG_LINUX_LOWMEM_MAX_SIZE);
if (size < getenv_bootm_size()) {
if (size < bootm_size) {
ulong base = bootmap_base + size;
printf("WARNING: adjusting available memory to %x\n", size);
lmb_reserve(lmb, base, getenv_bootm_size() - size);
lmb_reserve(lmb, base, bootm_size - size);
}
/*
@ -725,7 +727,7 @@ static int boot_relocate_fdt (struct lmb *lmb, ulong bootmap_base,
ulong of_start;
/* position on a 4K boundary before the alloc_current */
of_start = lmb_alloc_base(lmb, of_len, 0x1000,
of_start = (unsigned long)lmb_alloc_base(lmb, of_len, 0x1000,
(CFG_BOOTMAPSZ + bootmap_base));
if (of_start == 0) {

Write Preview
Loading…
Cancel
Save