[BACK]Return to fdt_machdep.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / arch / evbarm / fdt

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/arch/evbarm/fdt/fdt_machdep.c between version 1.63 and 1.98

version 1.63, 2019/07/15 08:44:33 version 1.98, 2022/10/21 05:51:08
Line 29 
Line 29 
 #include <sys/cdefs.h>  #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD$");  __KERNEL_RCSID(0, "$NetBSD$");
   
 #include "opt_machdep.h"  #include "opt_arm_debug.h"
 #include "opt_bootconfig.h"  #include "opt_bootconfig.h"
   #include "opt_cpuoptions.h"
 #include "opt_ddb.h"  #include "opt_ddb.h"
   #include "opt_efi.h"
   #include "opt_machdep.h"
 #include "opt_md.h"  #include "opt_md.h"
 #include "opt_arm_debug.h"  
 #include "opt_multiprocessor.h"  #include "opt_multiprocessor.h"
 #include "opt_cpuoptions.h"  
 #include "opt_efi.h"  
   
   #include "genfb.h"
 #include "ukbd.h"  #include "ukbd.h"
 #include "wsdisplay.h"  #include "wsdisplay.h"
   
 #include <sys/param.h>  #include <sys/param.h>
 #include <sys/systm.h>  #include <sys/types.h>
 #include <sys/bus.h>  
 #include <sys/atomic.h>  #include <sys/atomic.h>
   #include <sys/bootblock.h>
   #include <sys/bus.h>
   #include <sys/conf.h>
 #include <sys/cpu.h>  #include <sys/cpu.h>
 #include <sys/device.h>  #include <sys/device.h>
   #include <sys/disk.h>
   #include <sys/disklabel.h>
   #include <sys/endian.h>
 #include <sys/exec.h>  #include <sys/exec.h>
   #include <sys/fcntl.h>
   #include <sys/kauth.h>
 #include <sys/kernel.h>  #include <sys/kernel.h>
 #include <sys/kmem.h>  #include <sys/kmem.h>
 #include <sys/ksyms.h>  #include <sys/ksyms.h>
   #include <sys/md5.h>
 #include <sys/msgbuf.h>  #include <sys/msgbuf.h>
 #include <sys/proc.h>  #include <sys/proc.h>
   #include <sys/pserialize.h>
 #include <sys/reboot.h>  #include <sys/reboot.h>
   #include <sys/rnd.h>
   #include <sys/rndsource.h>
   #include <sys/systm.h>
 #include <sys/termios.h>  #include <sys/termios.h>
 #include <sys/bootblock.h>  
 #include <sys/disklabel.h>  
 #include <sys/vnode.h>  #include <sys/vnode.h>
 #include <sys/kauth.h>  
 #include <sys/fcntl.h>  
 #include <sys/uuid.h>  #include <sys/uuid.h>
 #include <sys/disk.h>  
 #include <sys/md5.h>  
 #include <sys/pserialize.h>  
   
 #include <net/if.h>  #include <net/if.h>
 #include <net/if_dl.h>  #include <net/if_dl.h>
Line 71  __KERNEL_RCSID(0, "$NetBSD$");
Line 78  __KERNEL_RCSID(0, "$NetBSD$");
 #include <dev/cons.h>  #include <dev/cons.h>
 #include <uvm/uvm_extern.h>  #include <uvm/uvm_extern.h>
   
 #include <sys/conf.h>  
   
 #include <machine/db_machdep.h>  #include <machine/db_machdep.h>
 #include <ddb/db_sym.h>  #include <ddb/db_sym.h>
 #include <ddb/db_extern.h>  #include <ddb/db_extern.h>
Line 85  __KERNEL_RCSID(0, "$NetBSD$");
Line 90  __KERNEL_RCSID(0, "$NetBSD$");
 #include <evbarm/include/autoconf.h>  #include <evbarm/include/autoconf.h>
 #include <evbarm/fdt/machdep.h>  #include <evbarm/fdt/machdep.h>
 #include <evbarm/fdt/platform.h>  #include <evbarm/fdt/platform.h>
 #include <evbarm/fdt/fdt_memory.h>  
   
 #include <arm/fdt/arm_fdtvar.h>  #include <arm/fdt/arm_fdtvar.h>
   #include <dev/fdt/fdt_private.h>
   #include <dev/fdt/fdt_memory.h>
   
 #ifdef EFI_RUNTIME  #ifdef EFI_RUNTIME
 #include <arm/arm/efi_runtime.h>  #include <arm/arm/efi_runtime.h>
 #endif  #endif
   
   #if NWSDISPLAY > 0 && NGENFB > 0
   #include <arm/fdt/arm_simplefb.h>
   #endif
   
 #if NUKBD > 0  #if NUKBD > 0
 #include <dev/usb/ukbdvar.h>  #include <dev/usb/ukbdvar.h>
 #endif  #endif
Line 117  u_long uboot_args[4] __attribute__((__se
Line 127  u_long uboot_args[4] __attribute__((__se
 const uint8_t *fdt_addr_r __attribute__((__section__(".data")));  const uint8_t *fdt_addr_r __attribute__((__section__(".data")));
   
 static uint64_t initrd_start, initrd_end;  static uint64_t initrd_start, initrd_end;
   static uint64_t rndseed_start, rndseed_end; /* our on-disk seed */
   static uint64_t efirng_start, efirng_end;   /* firmware's EFI RNG output */
   
 #include <libfdt.h>  #include <libfdt.h>
 #include <dev/fdt/fdtvar.h>  #include <dev/fdt/fdtvar.h>
Line 133  static void fdt_cpu_rootconf(void);
Line 145  static void fdt_cpu_rootconf(void);
 static void fdt_reset(void);  static void fdt_reset(void);
 static void fdt_powerdown(void);  static void fdt_powerdown(void);
   
   #if BYTE_ORDER == BIG_ENDIAN
   static void fdt_update_fb_format(void);
   #endif
   
 static void  static void
 earlyconsputc(dev_t dev, int c)  earlyconsputc(dev_t dev, int c)
 {  {
Line 142  earlyconsputc(dev_t dev, int c)
Line 158  earlyconsputc(dev_t dev, int c)
 static int  static int
 earlyconsgetc(dev_t dev)  earlyconsgetc(dev_t dev)
 {  {
         return 0;          return -1;
 }  }
   
 static struct consdev earlycons = {  static struct consdev earlycons = {
Line 157  static struct consdev earlycons = {
Line 173  static struct consdev earlycons = {
 #define VPRINTF(...)    __nothing  #define VPRINTF(...)    __nothing
 #endif  #endif
   
 /*  
  * Get all of physical memory, including holes.  
  */  
 static void  
 fdt_get_memory(uint64_t *pstart, uint64_t *pend)  
 {  
         const int memory = OF_finddevice("/memory");  
         uint64_t cur_addr, cur_size;  
         int index;  
   
         /* Assume the first entry is the start of memory */  
         if (fdtbus_get_reg64(memory, 0, &cur_addr, &cur_size) != 0)  
                 panic("Cannot determine memory size");  
   
         *pstart = cur_addr;  
         *pend = cur_addr + cur_size;  
   
         VPRINTF("FDT /memory [%d] @ 0x%" PRIx64 " size 0x%" PRIx64 "\n",  
             0, *pstart, *pend - *pstart);  
   
         for (index = 1;  
              fdtbus_get_reg64(memory, index, &cur_addr, &cur_size) == 0;  
              index++) {  
                 VPRINTF("FDT /memory [%d] @ 0x%" PRIx64 " size 0x%" PRIx64 "\n",  
                     index, cur_addr, cur_size);  
   
                 if (cur_addr + cur_size > *pend)  
                         *pend = cur_addr + cur_size;  
         }  
 }  
   
 void  
 fdt_add_reserved_memory_range(uint64_t addr, uint64_t size)  
 {  
         fdt_memory_remove_range(addr, size);  
 }  
   
 /*  
  * Exclude memory ranges from memory config from the device tree  
  */  
 static void  
 fdt_add_reserved_memory(uint64_t min_addr, uint64_t max_addr)  
 {  
         uint64_t lstart = 0, lend = 0;  
         uint64_t addr, size;  
         int index, error;  
   
         const int num = fdt_num_mem_rsv(fdtbus_get_data());  
         for (index = 0; index <= num; index++) {  
                 error = fdt_get_mem_rsv(fdtbus_get_data(), index,  
                     &addr, &size);  
                 if (error != 0)  
                         continue;  
                 if (lstart <= addr && addr <= lend) {  
                         size -= (lend - addr);  
                         addr = lend;  
                 }  
                 if (size == 0)  
                         continue;  
                 if (addr + size <= min_addr)  
                         continue;  
                 if (addr >= max_addr)  
                         continue;  
                 if (addr < min_addr) {  
                         size -= (min_addr - addr);  
                         addr = min_addr;  
                 }  
                 if (addr + size > max_addr)  
                         size = max_addr - addr;  
                 fdt_add_reserved_memory_range(addr, size);  
                 lstart = addr;  
                 lend = addr + size;  
         }  
 }  
   
 static void  static void
 fdt_add_dram_blocks(const struct fdt_memory *m, void *arg)  fdt_add_dram_blocks(const struct fdt_memory *m, void *arg)
 {  {
Line 269  fdt_add_boot_physmem(const struct fdt_me
Line 210  fdt_add_boot_physmem(const struct fdt_me
         bp->bp_pages = atop(eaddr) - bp->bp_start;          bp->bp_pages = atop(eaddr) - bp->bp_start;
         bp->bp_freelist = VM_FREELIST_DEFAULT;          bp->bp_freelist = VM_FREELIST_DEFAULT;
   
 #ifdef _LP64  
         if (m->end > 0x100000000)  
                 bp->bp_freelist = VM_FREELIST_HIGHMEM;  
 #endif  
   
 #ifdef PMAP_NEED_ALLOC_POOLPAGE  #ifdef PMAP_NEED_ALLOC_POOLPAGE
         const uint64_t memory_size = *(uint64_t *)arg;          const uint64_t memory_size = *(uint64_t *)arg;
         if (atop(memory_size) > bp->bp_pages) {          if (atop(memory_size) > bp->bp_pages) {
Line 283  fdt_add_boot_physmem(const struct fdt_me
Line 219  fdt_add_boot_physmem(const struct fdt_me
 #endif  #endif
 }  }
   
   
   static void
   fdt_print_memory(const struct fdt_memory *m, void *arg)
   {
   
           VPRINTF("FDT /memory @ 0x%" PRIx64 " size 0x%" PRIx64 "\n",
               m->start, m->end - m->start);
   }
   
   
 /*  /*
  * Define usable memory regions.   * Define usable memory regions.
  */   */
 static void  static void
 fdt_build_bootconfig(uint64_t mem_start, uint64_t mem_end)  fdt_build_bootconfig(uint64_t mem_start, uint64_t mem_end)
 {  {
         const int memory = OF_finddevice("/memory");  
         BootConfig *bc = &bootconfig;          BootConfig *bc = &bootconfig;
   
         uint64_t addr, size;          uint64_t addr, size;
         int index;          int index;
   
         for (index = 0;          const uint64_t initrd_size =
              fdtbus_get_reg64(memory, index, &addr, &size) == 0;              round_page(initrd_end) - trunc_page(initrd_start);
              index++) {  
                 if (addr >= mem_end || size == 0)  
                         continue;  
                 if (addr + size > mem_end)  
                         size = mem_end - addr;  
   
                 fdt_memory_add_range(addr, size);  
         }  
   
         fdt_add_reserved_memory(mem_start, mem_end);  
   
         const uint64_t initrd_size = initrd_end - initrd_start;  
         if (initrd_size > 0)          if (initrd_size > 0)
                 fdt_memory_remove_range(initrd_start, initrd_size);                  fdt_memory_remove_range(trunc_page(initrd_start), initrd_size);
   
           const uint64_t rndseed_size =
               round_page(rndseed_end) - trunc_page(rndseed_start);
           if (rndseed_size > 0)
                   fdt_memory_remove_range(trunc_page(rndseed_start),
                       rndseed_size);
   
           const uint64_t efirng_size =
               round_page(efirng_end) - trunc_page(efirng_start);
           if (efirng_size > 0)
                   fdt_memory_remove_range(trunc_page(efirng_start), efirng_size);
   
         const int framebuffer = OF_finddevice("/chosen/framebuffer");          const int framebuffer = OF_finddevice("/chosen/framebuffer");
         if (framebuffer >= 0) {          if (framebuffer >= 0) {
                 for (index = 0;                  for (index = 0;
                      fdtbus_get_reg64(framebuffer, index, &addr, &size) == 0;                       fdtbus_get_reg64(framebuffer, index, &addr, &size) == 0;
                      index++) {                       index++) {
                         fdt_add_reserved_memory_range(addr, size);                          fdt_memory_remove_range(addr, size);
                 }                  }
         }          }
   
Line 326  fdt_build_bootconfig(uint64_t mem_start,
Line 271  fdt_build_bootconfig(uint64_t mem_start,
 }  }
   
 static void  static void
 fdt_probe_initrd(uint64_t *pstart, uint64_t *pend)  fdt_probe_range(const char *startname, const char *endname,
       uint64_t *pstart, uint64_t *pend)
 {  {
           int chosen, len;
           const void *start_data, *end_data;
   
         *pstart = *pend = 0;          *pstart = *pend = 0;
   
 #ifdef MEMORY_DISK_DYNAMIC          chosen = OF_finddevice("/chosen");
         const int chosen = OF_finddevice("/chosen");  
         if (chosen < 0)          if (chosen < 0)
                 return;                  return;
   
         int len;          start_data = fdtbus_get_prop(chosen, startname, &len);
         const void *start_data = fdtbus_get_prop(chosen,          end_data = fdtbus_get_prop(chosen, endname, NULL);
             "linux,initrd-start", &len);  
         const void *end_data = fdtbus_get_prop(chosen,  
             "linux,initrd-end", NULL);  
         if (start_data == NULL || end_data == NULL)          if (start_data == NULL || end_data == NULL)
                 return;                  return;
   
Line 353  fdt_probe_initrd(uint64_t *pstart, uint6
Line 298  fdt_probe_initrd(uint64_t *pstart, uint6
                 *pend = be64dec(end_data);                  *pend = be64dec(end_data);
                 break;                  break;
         default:          default:
                 printf("Unsupported len %d for /chosen/initrd-start\n", len);                  printf("Unsupported len %d for /chosen `%s'\n",
                       len, startname);
                 return;                  return;
         }          }
 #endif  
 }  }
   
 static void  static void *
 fdt_setup_initrd(void)  fdt_map_range(uint64_t start, uint64_t end, uint64_t *psize,
       const char *purpose)
 {  {
 #ifdef MEMORY_DISK_DYNAMIC          const paddr_t startpa = trunc_page(start);
         const uint64_t initrd_size = initrd_end - initrd_start;          const paddr_t endpa = round_page(end);
         paddr_t startpa = trunc_page(initrd_start);  
         paddr_t endpa = round_page(initrd_end);  
         paddr_t pa;          paddr_t pa;
         vaddr_t va;          vaddr_t va;
         void *md_start;          void *ptr;
   
         if (initrd_size == 0)          *psize = end - start;
                 return;          if (*psize == 0)
                   return NULL;
   
           const vaddr_t voff = start & PAGE_MASK;
   
         va = uvm_km_alloc(kernel_map, initrd_size, 0,          va = uvm_km_alloc(kernel_map, *psize, 0, UVM_KMF_VAONLY | UVM_KMF_NOWAIT);
             UVM_KMF_VAONLY | UVM_KMF_NOWAIT);  
         if (va == 0) {          if (va == 0) {
                 printf("Failed to allocate VA for initrd\n");                  printf("Failed to allocate VA for %s\n", purpose);
                 return;                  return NULL;
         }          }
           ptr = (void *)(va + voff);
         md_start = (void *)va;  
   
         for (pa = startpa; pa < endpa; pa += PAGE_SIZE, va += PAGE_SIZE)          for (pa = startpa; pa < endpa; pa += PAGE_SIZE, va += PAGE_SIZE)
                 pmap_kenter_pa(va, pa, VM_PROT_READ|VM_PROT_WRITE, 0);                  pmap_kenter_pa(va, pa, VM_PROT_READ | VM_PROT_WRITE, 0);
           pmap_update(pmap_kernel());
   
           return ptr;
   }
   
   static void
   fdt_unmap_range(void *ptr, uint64_t size)
   {
           const char *start = ptr, *end = start + size;
           const vaddr_t startva = trunc_page((vaddr_t)(uintptr_t)start);
           const vaddr_t endva = round_page((vaddr_t)(uintptr_t)end);
           const vsize_t sz = endva - startva;
   
           pmap_kremove(startva, sz);
         pmap_update(pmap_kernel());          pmap_update(pmap_kernel());
   
           uvm_km_free(kernel_map, startva, sz, UVM_KMF_VAONLY);
   }
   
   static void
   fdt_probe_initrd(uint64_t *pstart, uint64_t *pend)
   {
           *pstart = *pend = 0;
   
   #ifdef MEMORY_DISK_DYNAMIC
           fdt_probe_range("linux,initrd-start", "linux,initrd-end", pstart, pend);
   #endif
   }
   
   static void
   fdt_setup_initrd(void)
   {
   #ifdef MEMORY_DISK_DYNAMIC
           void *md_start;
           uint64_t initrd_size;
   
           md_start = fdt_map_range(initrd_start, initrd_end, &initrd_size,
               "initrd");
           if (md_start == NULL)
                   return;
         md_root_setconf(md_start, initrd_size);          md_root_setconf(md_start, initrd_size);
 #endif  #endif
 }  }
   
   static void
   fdt_probe_rndseed(uint64_t *pstart, uint64_t *pend)
   {
   
           fdt_probe_range("netbsd,rndseed-start", "netbsd,rndseed-end",
               pstart, pend);
   }
   
   static void
   fdt_setup_rndseed(void)
   {
           uint64_t rndseed_size;
           void *rndseed;
   
           rndseed = fdt_map_range(rndseed_start, rndseed_end, &rndseed_size,
               "rndseed");
           if (rndseed == NULL)
                   return;
           rnd_seed(rndseed, rndseed_size);
           fdt_unmap_range(rndseed, rndseed_size);
   }
   
   static void
   fdt_probe_efirng(uint64_t *pstart, uint64_t *pend)
   {
   
           fdt_probe_range("netbsd,efirng-start", "netbsd,efirng-end",
               pstart, pend);
   }
   
   static struct krndsource efirng_source;
   
   static void
   fdt_setup_efirng(void)
   {
           uint64_t efirng_size;
           void *efirng;
   
           efirng = fdt_map_range(efirng_start, efirng_end, &efirng_size,
               "efirng");
           if (efirng == NULL)
                   return;
   
           rnd_attach_source(&efirng_source, "efirng", RND_TYPE_RNG,
               RND_FLAG_DEFAULT);
   
           /*
            * We don't really have specific information about the physical
            * process underlying the data provided by the firmware via the
            * EFI RNG API, so the entropy estimate here is heuristic.
            * What efiboot provides us is up to 4096 bytes of data from
            * the EFI RNG API, although in principle it may return short.
            *
            * The UEFI Specification (2.8 Errata A, February 2020[1]) says
            *
            *      When a Deterministic Random Bit Generator (DRBG) is
            *      used on the output of a (raw) entropy source, its
            *      security level must be at least 256 bits.
            *
            * It's not entirely clear whether `it' refers to the DRBG or
            * the entropy source; if it refers to the DRBG, it's not
            * entirely clear how ANSI X9.31 3DES, one of the options for
            * DRBG in the UEFI spec, can provide a `256-bit security
            * level' because it has only 232 bits of inputs (three 56-bit
            * keys and one 64-bit block).  That said, even if it provides
            * only 232 bits of entropy, that's enough to prevent all
            * attacks and we probably get a few more bits from sampling
            * the clock anyway.
            *
            * In the event we get raw samples, e.g. the bits sampled by a
            * ring oscillator, we hope that the samples have at least half
            * a bit of entropy per bit of data -- and efiboot tries to
            * draw 4096 bytes to provide plenty of slop.  Hence we divide
            * the total number of bits by two and clamp at 256.  There are
            * ways this could go wrong, but on most machines it should
            * behave reasonably.
            *
            * [1] https://uefi.org/sites/default/files/resources/UEFI_Spec_2_8_A_Feb14.pdf
            */
           rnd_add_data(&efirng_source, efirng, efirng_size,
               MIN(256, efirng_size*NBBY/2));
   
           explicit_memset(efirng, 0, efirng_size);
           fdt_unmap_range(efirng, efirng_size);
   }
   
 #ifdef EFI_RUNTIME  #ifdef EFI_RUNTIME
 static void  static void
 fdt_map_efi_runtime(const char *prop, enum arm_efirt_mem_type type)  fdt_map_efi_runtime(const char *prop, enum arm_efirt_mem_type type)
Line 407  fdt_map_efi_runtime(const char *prop, en
Line 476  fdt_map_efi_runtime(const char *prop, en
         while (len >= 24) {          while (len >= 24) {
                 const paddr_t pa = be64toh(map[0]);                  const paddr_t pa = be64toh(map[0]);
                 const vaddr_t va = be64toh(map[1]);                  const vaddr_t va = be64toh(map[1]);
                 const uint64_t sz = be64toh(map[2]);                  const size_t sz = be64toh(map[2]);
                 VPRINTF("%s: %s %lx-%lx (%lx-%lx)\n", __func__, prop, pa, pa+sz-1, va, va+sz-1);                  VPRINTF("%s: %s %#" PRIxPADDR "-%#" PRIxVADDR " (%#" PRIxVADDR
                       "-%#" PRIxVSIZE ")\n", __func__, prop, pa, pa + sz - 1,
                       va, va + sz - 1);
                 arm_efirt_md_map_range(va, pa, sz, type);                  arm_efirt_md_map_range(va, pa, sz, type);
                 map += 3;                  map += 3;
                 len -= 24;                  len -= 24;
Line 416  fdt_map_efi_runtime(const char *prop, en
Line 487  fdt_map_efi_runtime(const char *prop, en
 }  }
 #endif  #endif
   
 u_int initarm(void *arg);  vaddr_t
   
 u_int  
 initarm(void *arg)  initarm(void *arg)
 {  {
         const struct arm_platform *plat;          const struct arm_platform *plat;
Line 429  initarm(void *arg)
Line 498  initarm(void *arg)
   
         /* Load FDT */          /* Load FDT */
         int error = fdt_check_header(fdt_addr_r);          int error = fdt_check_header(fdt_addr_r);
         if (error == 0) {          if (error != 0)
                 /* If the DTB is too big, try to pack it in place first. */  
                 if (fdt_totalsize(fdt_addr_r) > sizeof(fdt_data))  
                         (void)fdt_pack(__UNCONST(fdt_addr_r));  
                 error = fdt_open_into(fdt_addr_r, fdt_data, sizeof(fdt_data));  
                 if (error != 0)  
                         panic("fdt_move failed: %s", fdt_strerror(error));  
                 fdtbus_set_data(fdt_data);  
         } else {  
                 panic("fdt_check_header failed: %s", fdt_strerror(error));                  panic("fdt_check_header failed: %s", fdt_strerror(error));
         }  
           /* If the DTB is too big, try to pack it in place first. */
           if (fdt_totalsize(fdt_addr_r) > sizeof(fdt_data))
                   (void)fdt_pack(__UNCONST(fdt_addr_r));
   
           error = fdt_open_into(fdt_addr_r, fdt_data, sizeof(fdt_data));
           if (error != 0)
                   panic("fdt_move failed: %s", fdt_strerror(error));
   
           fdtbus_init(fdt_data);
   
         /* Lookup platform specific backend */          /* Lookup platform specific backend */
         plat = arm_fdt_platform();          plat = arm_fdt_platform();
Line 464  initarm(void *arg)
Line 534  initarm(void *arg)
          * l1pt VA is fine           * l1pt VA is fine
          */           */
   
         VPRINTF("devmap\n");          VPRINTF("devmap %p\n", plat->ap_devmap());
         extern char ARM_BOOTSTRAP_LxPT[];          extern char ARM_BOOTSTRAP_LxPT[];
         pmap_devmap_bootstrap((vaddr_t)ARM_BOOTSTRAP_LxPT, plat->ap_devmap());          pmap_devmap_bootstrap((vaddr_t)ARM_BOOTSTRAP_LxPT, plat->ap_devmap());
   
Line 478  initarm(void *arg)
Line 548  initarm(void *arg)
         VPRINTF("stdout\n");          VPRINTF("stdout\n");
         fdt_update_stdout_path();          fdt_update_stdout_path();
   
   #if BYTE_ORDER == BIG_ENDIAN
           /*
            * Most boards are configured to little-endian mode initially, and
            * switched to big-endian mode after kernel is loaded. In this case,
            * framebuffer seems byte-swapped to CPU. Override FDT to let
            * drivers know.
            */
           VPRINTF("fb_format\n");
           fdt_update_fb_format();
   #endif
   
         /*          /*
          * Done making changes to the FDT.           * Done making changes to the FDT.
          */           */
Line 504  initarm(void *arg)
Line 585  initarm(void *arg)
         parse_mi_bootargs(mi_bootargs);          parse_mi_bootargs(mi_bootargs);
 #endif  #endif
   
         fdt_get_memory(&memory_start, &memory_end);          fdt_memory_get(&memory_start, &memory_end);
   
 #if !defined(_LP64)          fdt_memory_foreach(fdt_print_memory, NULL);
         /* Cannot map memory above 4GB */  
         if (memory_end >= 0x100000000ULL)  
                 memory_end = 0x100000000ULL - PAGE_SIZE;  
   
   #if !defined(_LP64)
           /* Cannot map memory above 4GB (remove last page as well) */
           const uint64_t memory_limit = 0x100000000ULL - PAGE_SIZE;
           if (memory_end > memory_limit) {
                   fdt_memory_remove_range(memory_limit , memory_end);
                   memory_end = memory_limit;
           }
 #endif  #endif
         uint64_t memory_size = memory_end - memory_start;          uint64_t memory_size = memory_end - memory_start;
   
Line 520  initarm(void *arg)
Line 605  initarm(void *arg)
         /* Parse ramdisk info */          /* Parse ramdisk info */
         fdt_probe_initrd(&initrd_start, &initrd_end);          fdt_probe_initrd(&initrd_start, &initrd_end);
   
           /* Parse our on-disk rndseed and the firmware's RNG from EFI */
           fdt_probe_rndseed(&rndseed_start, &rndseed_end);
           fdt_probe_efirng(&efirng_start, &efirng_end);
   
           fdt_memory_remove_reserved(memory_start, memory_end);
   
         /*          /*
          * Populate bootconfig structure for the benefit of           * Populate bootconfig structure for the benefit of dodumpsys
          * dodumpsys  
          */           */
         VPRINTF("%s: fdt_build_bootconfig\n", __func__);          VPRINTF("%s: fdt_build_bootconfig\n", __func__);
         fdt_build_bootconfig(memory_start, memory_end);          fdt_build_bootconfig(memory_start, memory_end);
   
 #ifdef EFI_RUNTIME  
         fdt_map_efi_runtime("netbsd,uefi-runtime-code", ARM_EFIRT_MEM_CODE);  
         fdt_map_efi_runtime("netbsd,uefi-runtime-data", ARM_EFIRT_MEM_DATA);  
         fdt_map_efi_runtime("netbsd,uefi-runtime-mmio", ARM_EFIRT_MEM_MMIO);  
 #endif  
   
         /* Perform PT build and VM init */          /* Perform PT build and VM init */
         cpu_kernel_vm_init(memory_start, memory_size);          cpu_kernel_vm_init(memory_start, memory_size);
   
Line 541  initarm(void *arg)
Line 625  initarm(void *arg)
         parse_mi_bootargs(boot_args);          parse_mi_bootargs(boot_args);
   
         VPRINTF("Memory regions:\n");          VPRINTF("Memory regions:\n");
   
           /* Populate fdt_physmem / nfdt_physmem for initarm_common */
         fdt_memory_foreach(fdt_add_boot_physmem, &memory_size);          fdt_memory_foreach(fdt_add_boot_physmem, &memory_size);
   
         u_int sp = initarm_common(KERNEL_VM_BASE, KERNEL_VM_SIZE, fdt_physmem,          vaddr_t sp = initarm_common(KERNEL_VM_BASE, KERNEL_VM_SIZE, fdt_physmem,
              nfdt_physmem);               nfdt_physmem);
   
         /*          /*
Line 558  initarm(void *arg)
Line 644  initarm(void *arg)
   
         if (error)          if (error)
                 return sp;                  return sp;
   
         /*          /*
          * Now we have APs started the pages used for stacks and L1PT can           * Now we have APs started the pages used for stacks and L1PT can
          * be given to uvm           * be given to uvm
Line 575  initarm(void *arg)
Line 662  initarm(void *arg)
                     "loading in freelist %d\n", spa, epa, VM_FREELIST_DEFAULT);                      "loading in freelist %d\n", spa, epa, VM_FREELIST_DEFAULT);
   
                 uvm_page_physload(spg, epg, spg, epg, VM_FREELIST_DEFAULT);                  uvm_page_physload(spg, epg, spg, epg, VM_FREELIST_DEFAULT);
   
         }          }
   
         return sp;          return sp;
Line 631  consinit(void)
Line 717  consinit(void)
 }  }
   
 void  void
   cpu_startup_hook(void)
   {
   #ifdef EFI_RUNTIME
           fdt_map_efi_runtime("netbsd,uefi-runtime-code", ARM_EFIRT_MEM_CODE);
           fdt_map_efi_runtime("netbsd,uefi-runtime-data", ARM_EFIRT_MEM_DATA);
           fdt_map_efi_runtime("netbsd,uefi-runtime-mmio", ARM_EFIRT_MEM_MMIO);
   #endif
   
           fdtbus_intr_init();
   
           fdt_setup_rndseed();
           fdt_setup_efirng();
   }
   
   void
 delay(u_int us)  delay(u_int us)
 {  {
         const struct arm_platform *plat = arm_fdt_platform();          const struct arm_platform *plat = arm_fdt_platform();
Line 675  fdt_detect_root_device(device_t dev)
Line 776  fdt_detect_root_device(device_t dev)
                 if (!vp)                  if (!vp)
                         return;                          return;
                 error = vn_rdwr(UIO_READ, vp, buf, sizeof(buf), 0, UIO_SYSSPACE,                  error = vn_rdwr(UIO_READ, vp, buf, sizeof(buf), 0, UIO_SYSSPACE,
                     0, NOCRED, &resid, NULL);                      IO_NODELOCKED, NOCRED, &resid, NULL);
                 VOP_CLOSE(vp, FREAD, NOCRED);                  VOP_CLOSE(vp, FREAD, NOCRED);
                 vput(vp);                  vput(vp);
   
Line 738  fdt_device_register(device_t self, void 
Line 839  fdt_device_register(device_t self, void 
 {  {
         const struct arm_platform *plat = arm_fdt_platform();          const struct arm_platform *plat = arm_fdt_platform();
   
         if (device_is_a(self, "armfdt"))          if (device_is_a(self, "armfdt")) {
                 fdt_setup_initrd();                  fdt_setup_initrd();
   
   #if NWSDISPLAY > 0 && NGENFB > 0
                   /*
                    * Setup framebuffer console, if present.
                    */
                   arm_simplefb_preattach();
   #endif
           }
   
   #if NWSDISPLAY > 0 && NGENFB > 0
           if (device_is_a(self, "genfb")) {
                   prop_dictionary_t dict = device_properties(self);
                   prop_dictionary_set_uint64(dict,
                       "simplefb-physaddr", arm_simplefb_physaddr());
           }
   #endif
   
         if (plat && plat->ap_device_register)          if (plat && plat->ap_device_register)
                 plat->ap_device_register(self, aux);                  plat->ap_device_register(self, aux);
 }  }
Line 764  fdt_cpu_rootconf(void)
Line 881  fdt_cpu_rootconf(void)
         deviter_t di;          deviter_t di;
         char *ptr;          char *ptr;
   
           if (booted_device != NULL)
                   return;
   
         for (dev = deviter_first(&di, 0); dev; dev = deviter_next(&di)) {          for (dev = deviter_first(&di, 0); dev; dev = deviter_next(&di)) {
                 if (device_class(dev) != DV_DISK)                  if (device_class(dev) != DV_DISK)
                         continue;                          continue;
Line 793  fdt_powerdown(void)
Line 913  fdt_powerdown(void)
 {  {
         fdtbus_power_poweroff();          fdtbus_power_poweroff();
 }  }
   
   #if BYTE_ORDER == BIG_ENDIAN
   static void
   fdt_update_fb_format(void)
   {
           int off, len;
           const char *format, *replace;
   
           off = fdt_path_offset(fdt_data, "/chosen");
           if (off < 0)
                   return;
   
           for (;;) {
                   off = fdt_node_offset_by_compatible(fdt_data, off,
                       "simple-framebuffer");
                   if (off < 0)
                           return;
   
                   format = fdt_getprop(fdt_data, off, "format", &len);
                   if (format == NULL)
                           continue;
   
                   replace = NULL;
                   if (strcmp(format, "a8b8g8r8") == 0)
                           replace = "r8g8b8a8";
                   else if (strcmp(format, "x8r8g8b8") == 0)
                           replace = "b8g8r8x8";
                   if (replace != NULL)
                           fdt_setprop(fdt_data, off, "format", replace,
                               strlen(replace) + 1);
           }
   }
   #endif
Legend:
Removed from v.1.63  
changed lines
  Added in v.1.98
CVSweb <webmaster@jp.NetBSD.org>