common/memsize.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2004
   4  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   5  */
   6
   7 #include <common.h>
   8
   9 DECLARE_GLOBAL_DATA_PTR;
  10
  11 #ifdef __PPC__
  12 /*
  13  * At least on G2 PowerPC cores, sequential accesses to non-existent
  14  * memory must be synchronized.
  15  */
  16 # include <asm/io.h>    /* for sync() */
  17 #else
  18 # define sync()         /* nothing */
  19 #endif
  20
  21 /*
  22  * Check memory range for valid RAM. A simple memory test determines
  23  * the actually available RAM size between addresses `base' and
  24  * `base + maxsize'.
  25  */
  26 long get_ram_size(long *base, long maxsize)
  27 {
  28         volatile long *addr;
  29         long           save[BITS_PER_LONG - 1];
  30         long           save_base;
  31         long           cnt;
  32         long           val;
  33         long           size;
  34         int            i = 0;
  35
  36         for (cnt = (maxsize / sizeof(long)) >> 1; cnt > 0; cnt >>= 1) {
  37                 addr = base + cnt;      /* pointer arith! */
  38                 sync();
  39                 save[i++] = *addr;
  40                 sync();
  41                 *addr = ~cnt;
  42         }
  43
  44         addr = base;
  45         sync();
  46         save_base = *addr;
  47         sync();
  48         *addr = 0;
  49
  50         sync();
  51         if ((val = *addr) != 0) {
  52                 /* Restore the original data before leaving the function. */
  53                 sync();
  54                 *base = save_base;
  55                 for (cnt = 1; cnt < maxsize / sizeof(long); cnt <<= 1) {
  56                         addr  = base + cnt;
  57                         sync();
  58                         *addr = save[--i];
  59                 }
  60                 return (0);
  61         }
  62
  63         for (cnt = 1; cnt < maxsize / sizeof(long); cnt <<= 1) {
  64                 addr = base + cnt;      /* pointer arith! */
  65                 val = *addr;
  66                 *addr = save[--i];
  67                 if (val != ~cnt) {
  68                         size = cnt * sizeof(long);
  69                         /*
  70                          * Restore the original data
  71                          * before leaving the function.
  72                          */
  73                         for (cnt <<= 1;
  74                              cnt < maxsize / sizeof(long);
  75                              cnt <<= 1) {
  76                                 addr  = base + cnt;
  77                                 *addr = save[--i];
  78                         }
  79                         /* warning: don't restore save_base in this case,
  80                          * it is already done in the loop because
  81                          * base and base+size share the same physical memory
  82                          * and *base is saved after *(base+size) modification
  83                          * in first loop
  84                          */
  85                         return (size);
  86                 }
  87         }
  88         *base = save_base;
  89
  90         return (maxsize);
  91 }
  92
  93 phys_size_t __weak get_effective_memsize(void)
  94 {
  95 #ifndef CONFIG_VERY_BIG_RAM
  96         return gd->ram_size;
  97 #else
  98         /* limit stack to what we can reasonable map */
  99         return ((gd->ram_size > CONFIG_MAX_MEM_MAPPED) ?
 100                 CONFIG_MAX_MEM_MAPPED : gd->ram_size);
 101 #endif
 102 }