[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.7 and 1.24.2.2

version 1.7, 2017/06/11 20:25:07 version 1.24.2.2, 2020/04/08 14:07:35
Line 30 
Line 30 
 __KERNEL_RCSID(0, "$NetBSD$");  __KERNEL_RCSID(0, "$NetBSD$");
   
 #include "opt_machdep.h"  #include "opt_machdep.h"
   #include "opt_bootconfig.h"
 #include "opt_ddb.h"  #include "opt_ddb.h"
 #include "opt_md.h"  #include "opt_md.h"
 #include "opt_arm_debug.h"  #include "opt_arm_debug.h"
 #include "opt_multiprocessor.h"  #include "opt_multiprocessor.h"
 #include "opt_cpuoptions.h"  #include "opt_cpuoptions.h"
   #include "opt_efi.h"
   
   #include "ukbd.h"
   #include "wsdisplay.h"
   
 #include <sys/param.h>  #include <sys/param.h>
 #include <sys/systm.h>  #include <sys/systm.h>
Line 50  __KERNEL_RCSID(0, "$NetBSD$");
Line 55  __KERNEL_RCSID(0, "$NetBSD$");
 #include <sys/proc.h>  #include <sys/proc.h>
 #include <sys/reboot.h>  #include <sys/reboot.h>
 #include <sys/termios.h>  #include <sys/termios.h>
   #include <sys/bootblock.h>
   #include <sys/disklabel.h>
   #include <sys/vnode.h>
   #include <sys/kauth.h>
   #include <sys/fcntl.h>
   #include <sys/uuid.h>
   #include <sys/disk.h>
   #include <sys/md5.h>
   #include <sys/pserialize.h>
   #include <sys/rnd.h>
   
   #include <net/if.h>
   #include <net/if_dl.h>
   
   #include <dev/cons.h>
 #include <uvm/uvm_extern.h>  #include <uvm/uvm_extern.h>
   
 #include <sys/conf.h>  #include <sys/conf.h>
Line 61  __KERNEL_RCSID(0, "$NetBSD$");
Line 80  __KERNEL_RCSID(0, "$NetBSD$");
   
 #include <machine/bootconfig.h>  #include <machine/bootconfig.h>
 #include <arm/armreg.h>  #include <arm/armreg.h>
 #include <arm/undefined.h>  
   
 #include <arm/arm32/machdep.h>  #include <arm/cpufunc.h>
   
 #include <evbarm/include/autoconf.h>  #include <evbarm/include/autoconf.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>
   
   #ifdef EFI_RUNTIME
   #include <arm/arm/efi_runtime.h>
   #endif
   
   #if NUKBD > 0
   #include <dev/usb/ukbdvar.h>
   #endif
   #if NWSDISPLAY > 0
   #include <dev/wscons/wsdisplayvar.h>
   #endif
   
   #ifdef MEMORY_DISK_DYNAMIC
   #include <dev/md.h>
   #endif
   
 #ifndef FDT_MAX_BOOT_STRING  #ifndef FDT_MAX_BOOT_STRING
 #define FDT_MAX_BOOT_STRING 1024  #define FDT_MAX_BOOT_STRING 1024
Line 77  __KERNEL_RCSID(0, "$NetBSD$");
Line 113  __KERNEL_RCSID(0, "$NetBSD$");
 BootConfig bootconfig;  BootConfig bootconfig;
 char bootargs[FDT_MAX_BOOT_STRING] = "";  char bootargs[FDT_MAX_BOOT_STRING] = "";
 char *boot_args = NULL;  char *boot_args = NULL;
 u_int uboot_args[4] = { 0 };    /* filled in by xxx_start.S (not in bss) */  
   /* filled in before cleaning bss. keep in .data */
   u_long uboot_args[4] __attribute__((__section__(".data")));
   const uint8_t *fdt_addr_r __attribute__((__section__(".data")));
   
   static uint64_t initrd_start, initrd_end;
   static uint64_t rndseed_start, rndseed_end;
   
 #include <libfdt.h>  #include <libfdt.h>
 #include <dev/fdt/fdtvar.h>  #include <dev/fdt/fdtvar.h>
 #define FDT_BUF_SIZE    (128*1024)  #define FDT_BUF_SIZE    (512*1024)
 static uint8_t fdt_data[FDT_BUF_SIZE];  static uint8_t fdt_data[FDT_BUF_SIZE];
   
 extern char KERNEL_BASE_phys[];  extern char KERNEL_BASE_phys[];
Line 89  extern char KERNEL_BASE_phys[];
Line 131  extern char KERNEL_BASE_phys[];
   
 static void fdt_update_stdout_path(void);  static void fdt_update_stdout_path(void);
 static void fdt_device_register(device_t, void *);  static void fdt_device_register(device_t, void *);
   static void fdt_device_register_post_config(device_t, void *);
   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);
   
 #ifdef PMAP_NEED_ALLOC_POOLPAGE  
 static struct boot_physmem bp_lowgig = {  
         .bp_pages = (KERNEL_VM_BASE - KERNEL_BASE) / NBPG,  
         .bp_freelist = VM_FREELIST_ISADMA,  
         .bp_flags = 0  
 };  
 #endif  
   
 #ifdef VERBOSE_INIT_ARM  
 static void  static void
 fdt_putchar(char c)  earlyconsputc(dev_t dev, int c)
 {  {
         const struct arm_platform *plat = arm_fdt_platform();          uartputc(c);
         if (plat && plat->early_putchar)  
                 plat->early_putchar(c);  
 }  }
   
 static void  static int
 fdt_putstr(const char *s)  earlyconsgetc(dev_t dev)
 {  {
         for (const char *p = s; *p; p++)          return 0;
                 fdt_putchar(*p);  
 }  }
   
 static void  static struct consdev earlycons = {
 fdt_printn(u_int n, int base)          .cn_putc = earlyconsputc,
 {          .cn_getc = earlyconsgetc,
         char *p, buf[(sizeof(u_int) * NBBY / 3) + 1 + 2 /* ALT + SIGN */];          .cn_pollc = nullcnpollc,
   };
         p = buf;  
         do {  
                 *p++ = hexdigits[n % base];  
         } while (n /= base);  
   
         do {  #ifdef VERBOSE_INIT_ARM
                 fdt_putchar(*--p);  #define VPRINTF(...)    printf(__VA_ARGS__)
         } while (p > buf);  
 }  
 #define DPRINTF(...)            printf(__VA_ARGS__)  
 #define DPRINT(x)               fdt_putstr(x)  
 #define DPRINTN(x,b)            fdt_printn((x), (b))  
 #else  #else
 #define DPRINTF(...)  #define VPRINTF(...)    __nothing
 #define DPRINT(x)  
 #define DPRINTN(x,b)  
 #endif  #endif
   
 /*  /*
  * Get the first physically contiguous region of memory.   * Get all of physical memory, including holes.
  */   */
 static void  static void
 fdt_get_memory(uint64_t *paddr, uint64_t *psize)  fdt_get_memory(uint64_t *pstart, uint64_t *pend)
 {  {
         const int memory = OF_finddevice("/memory");          const int memory = OF_finddevice("/memory");
         uint64_t cur_addr, cur_size;          uint64_t cur_addr, cur_size;
         int index;          int index;
   
         /* Assume the first entry is the start of memory */          /* Assume the first entry is the start of memory */
         if (fdtbus_get_reg64(memory, 0, paddr, psize) != 0)          if (fdtbus_get_reg64(memory, 0, &cur_addr, &cur_size) != 0)
                 panic("Cannot determine memory size");                  panic("Cannot determine memory size");
   
         DPRINTF("FDT /memory [%d] @ 0x%" PRIx64 " size 0x%" PRIx64 "\n",          *pstart = cur_addr;
             0, *paddr, *psize);          *pend = cur_addr + cur_size;
   
           VPRINTF("FDT /memory [%d] @ 0x%" PRIx64 " size 0x%" PRIx64 "\n",
               0, *pstart, *pend - *pstart);
   
         /* If subsequent entries follow the previous one, append them. */  
         for (index = 1;          for (index = 1;
              fdtbus_get_reg64(memory, index, &cur_addr, &cur_size) == 0;               fdtbus_get_reg64(memory, index, &cur_addr, &cur_size) == 0;
              index++) {               index++) {
                 DPRINTF("FDT /memory [%d] @ 0x%" PRIx64 " size 0x%" PRIx64 "\n",                  VPRINTF("FDT /memory [%d] @ 0x%" PRIx64 " size 0x%" PRIx64 "\n",
                     index, cur_addr, cur_size);                      index, cur_addr, cur_size);
                 if (*paddr + *psize == cur_addr)  
                         *psize += 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
   fdt_add_dram_blocks(const struct fdt_memory *m, void *arg)
   {
           BootConfig *bc = arg;
   
           VPRINTF("  %" PRIx64 " - %" PRIx64 "\n", m->start, m->end - 1);
           bc->dram[bc->dramblocks].address = m->start;
           bc->dram[bc->dramblocks].pages =
               (m->end - m->start) / PAGE_SIZE;
           bc->dramblocks++;
   }
   
   #define MAX_PHYSMEM 64
   static int nfdt_physmem = 0;
   static struct boot_physmem fdt_physmem[MAX_PHYSMEM];
   
   static void
   fdt_add_boot_physmem(const struct fdt_memory *m, void *arg)
   {
           const paddr_t saddr = round_page(m->start);
           const paddr_t eaddr = trunc_page(m->end);
   
           VPRINTF("  %" PRIx64 " - %" PRIx64, m->start, m->end - 1);
           if (saddr >= eaddr) {
                   VPRINTF(" skipped\n");
                   return;
           }
           VPRINTF("\n");
   
           struct boot_physmem *bp = &fdt_physmem[nfdt_physmem++];
   
           KASSERT(nfdt_physmem <= MAX_PHYSMEM);
   
           bp->bp_start = atop(saddr);
           bp->bp_pages = atop(eaddr) - bp->bp_start;
           bp->bp_freelist = VM_FREELIST_DEFAULT;
   
   #ifdef PMAP_NEED_ALLOC_POOLPAGE
           const uint64_t memory_size = *(uint64_t *)arg;
           if (atop(memory_size) > bp->bp_pages) {
                   arm_poolpage_vmfreelist = VM_FREELIST_DIRECTMAP;
                   bp->bp_freelist = VM_FREELIST_DIRECTMAP;
           }
   #endif
   }
   
   /*
    * Define usable memory regions.
    */
   static void
   fdt_build_bootconfig(uint64_t mem_start, uint64_t mem_end)
   {
           const int memory = OF_finddevice("/memory");
           BootConfig *bc = &bootconfig;
           uint64_t addr, size;
           int index;
   
           for (index = 0;
                fdtbus_get_reg64(memory, index, &addr, &size) == 0;
                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)
                   fdt_memory_remove_range(initrd_start, initrd_size);
   
           const uint64_t rndseed_size = rndseed_end - rndseed_start;
           if (rndseed_size > 0)
                   fdt_memory_remove_range(rndseed_start, rndseed_size);
   
           const int framebuffer = OF_finddevice("/chosen/framebuffer");
           if (framebuffer >= 0) {
                   for (index = 0;
                        fdtbus_get_reg64(framebuffer, index, &addr, &size) == 0;
                        index++) {
                           fdt_add_reserved_memory_range(addr, size);
                   }
           }
   
           VPRINTF("Usable memory:\n");
           bc->dramblocks = 0;
           fdt_memory_foreach(fdt_add_dram_blocks, bc);
   }
   
   static void
   fdt_probe_initrd(uint64_t *pstart, uint64_t *pend)
   {
           *pstart = *pend = 0;
   
   #ifdef MEMORY_DISK_DYNAMIC
           const int chosen = OF_finddevice("/chosen");
           if (chosen < 0)
                   return;
   
           int len;
           const void *start_data = fdtbus_get_prop(chosen,
               "linux,initrd-start", &len);
           const void *end_data = fdtbus_get_prop(chosen,
               "linux,initrd-end", NULL);
           if (start_data == NULL || end_data == NULL)
                   return;
   
           switch (len) {
           case 4:
                   *pstart = be32dec(start_data);
                   *pend = be32dec(end_data);
                   break;
           case 8:
                   *pstart = be64dec(start_data);
                   *pend = be64dec(end_data);
                   break;
           default:
                   printf("Unsupported len %d for /chosen/initrd-start\n", len);
                   return;
           }
   #endif
   }
   
   static void
   fdt_setup_initrd(void)
   {
   #ifdef MEMORY_DISK_DYNAMIC
           const uint64_t initrd_size = initrd_end - initrd_start;
           paddr_t startpa = trunc_page(initrd_start);
           paddr_t endpa = round_page(initrd_end);
           paddr_t pa;
           vaddr_t va;
           void *md_start;
   
           if (initrd_size == 0)
                   return;
   
           va = uvm_km_alloc(kernel_map, initrd_size, 0,
               UVM_KMF_VAONLY | UVM_KMF_NOWAIT);
           if (va == 0) {
                   printf("Failed to allocate VA for initrd\n");
                   return;
           }
   
           md_start = (void *)va;
   
           for (pa = startpa; pa < endpa; pa += PAGE_SIZE, va += PAGE_SIZE)
                   pmap_kenter_pa(va, pa, VM_PROT_READ|VM_PROT_WRITE, 0);
           pmap_update(pmap_kernel());
   
           md_root_setconf(md_start, initrd_size);
   #endif
   }
   
   static void
   fdt_probe_rndseed(uint64_t *pstart, uint64_t *pend)
   {
           int chosen, len;
           const void *start_data, *end_data;
   
           *pstart = *pend = 0;
           chosen = OF_finddevice("/chosen");
           if (chosen < 0)
                   return;
   
           start_data = fdtbus_get_prop(chosen, "netbsd,rndseed-start", &len);
           end_data = fdtbus_get_prop(chosen, "netbsd,rndseed-end", NULL);
           if (start_data == NULL || end_data == NULL)
                   return;
   
           switch (len) {
           case 4:
                   *pstart = be32dec(start_data);
                   *pend = be32dec(end_data);
                   break;
           case 8:
                   *pstart = be64dec(start_data);
                   *pend = be64dec(end_data);
                   break;
           default:
                   printf("Unsupported len %d for /chosen/rndseed-start\n", len);
                   return;
         }          }
 }  }
   
   static void
   fdt_setup_rndseed(void)
   {
           const uint64_t rndseed_size = rndseed_end - rndseed_start;
           const paddr_t startpa = trunc_page(rndseed_start);
           const paddr_t endpa = round_page(rndseed_end);
           paddr_t pa;
           vaddr_t va;
           void *rndseed;
   
           if (rndseed_size == 0)
                   return;
   
           va = uvm_km_alloc(kernel_map, endpa - startpa, 0,
               UVM_KMF_VAONLY | UVM_KMF_NOWAIT);
           if (va == 0) {
                   printf("Failed to allocate VA for rndseed\n");
                   return;
           }
           rndseed = (void *)va;
   
           for (pa = startpa; pa < endpa; pa += PAGE_SIZE, va += PAGE_SIZE)
                   pmap_kenter_pa(va, pa, VM_PROT_READ|VM_PROT_WRITE, 0);
           pmap_update(pmap_kernel());
   
           rnd_seed(rndseed, rndseed_size);
   }
   
   #ifdef EFI_RUNTIME
   static void
   fdt_map_efi_runtime(const char *prop, enum arm_efirt_mem_type type)
   {
           int len;
   
           const int chosen_off = fdt_path_offset(fdt_data, "/chosen");
           if (chosen_off < 0)
                   return;
   
           const uint64_t *map = fdt_getprop(fdt_data, chosen_off, prop, &len);
           if (map == NULL)
                   return;
   
           while (len >= 24) {
                   const paddr_t pa = be64toh(map[0]);
                   const vaddr_t va = be64toh(map[1]);
                   const uint64_t sz = be64toh(map[2]);
                   VPRINTF("%s: %s %lx-%lx (%lx-%lx)\n", __func__, prop, pa, pa+sz-1, va, va+sz-1);
                   arm_efirt_md_map_range(va, pa, sz, type);
                   map += 3;
                   len -= 24;
           }
   }
   #endif
   
   u_int initarm(void *arg);
   
 u_int  u_int
 initarm(void *arg)  initarm(void *arg)
 {  {
         const struct arm_platform *plat;          const struct arm_platform *plat;
         uint64_t memory_addr, memory_size;          uint64_t memory_start, memory_end;
         psize_t ram_size = 0;  
           /* set temporally to work printf()/panic() even before consinit() */
           cn_tab = &earlycons;
   
         /* Load FDT */          /* Load FDT */
         const uint8_t *fdt_addr_r = (const uint8_t *)uboot_args[2];  
         int error = fdt_check_header(fdt_addr_r);          int error = fdt_check_header(fdt_addr_r);
         if (error == 0) {          if (error == 0) {
                 error = fdt_move(fdt_addr_r, fdt_data, sizeof(fdt_data));                  /* 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)                  if (error != 0)
                         panic("fdt_move failed: %s", fdt_strerror(error));                          panic("fdt_move failed: %s", fdt_strerror(error));
                 fdtbus_set_data(fdt_data);                  fdtbus_init(fdt_data);
         } else {          } else {
                 panic("fdt_check_header failed: %s", fdt_strerror(error));                  panic("fdt_check_header failed: %s", fdt_strerror(error));
         }          }
Line 192  initarm(void *arg)
Line 508  initarm(void *arg)
                 panic("Kernel does not support this device");                  panic("Kernel does not support this device");
   
         /* Early console may be available, announce ourselves. */          /* Early console may be available, announce ourselves. */
         DPRINT("FDT<");          VPRINTF("FDT<%p>\n", fdt_addr_r);
         DPRINTN((uintptr_t)fdt_addr_r, 16);  
         DPRINT(">");  
   
         const int chosen = OF_finddevice("/chosen");          const int chosen = OF_finddevice("/chosen");
         if (chosen >= 0)          if (chosen >= 0)
                 OF_getprop(chosen, "bootargs", bootargs, sizeof(bootargs));                  OF_getprop(chosen, "bootargs", bootargs, sizeof(bootargs));
         boot_args = bootargs;          boot_args = bootargs;
   
         DPRINT(" devmap");  
         pmap_devmap_register(plat->devmap());  
   
         DPRINT(" bootstrap");  
         plat->bootstrap();  
   
         /* Heads up ... Setup the CPU / MMU / TLB functions. */          /* Heads up ... Setup the CPU / MMU / TLB functions. */
         DPRINT(" cpufunc");          VPRINTF("cpufunc\n");
         if (set_cpufuncs())          if (set_cpufuncs())
                 panic("cpu not recognized!");                  panic("cpu not recognized!");
   
         /*          /*
            * Memory is still identity/flat mapped this point so using ttbr for
            * l1pt VA is fine
            */
   
           VPRINTF("devmap\n");
           extern char ARM_BOOTSTRAP_LxPT[];
           pmap_devmap_bootstrap((vaddr_t)ARM_BOOTSTRAP_LxPT, plat->ap_devmap());
   
           VPRINTF("bootstrap\n");
           plat->ap_bootstrap();
   
           /*
          * If stdout-path is specified on the command line, override the           * If stdout-path is specified on the command line, override the
          * value in /chosen/stdout-path before initializing console.           * value in /chosen/stdout-path before initializing console.
          */           */
           VPRINTF("stdout\n");
         fdt_update_stdout_path();          fdt_update_stdout_path();
   
         DPRINT(" consinit");          /*
         consinit();           * Done making changes to the FDT.
            */
           fdt_pack(fdt_data);
   
         DPRINTF(" ok\n");          VPRINTF("consinit ");
           consinit();
           VPRINTF("ok\n");
   
         DPRINTF("uboot: args %#x, %#x, %#x, %#x\n",          VPRINTF("uboot: args %#lx, %#lx, %#lx, %#lx\n",
             uboot_args[0], uboot_args[1], uboot_args[2], uboot_args[3]);              uboot_args[0], uboot_args[1], uboot_args[2], uboot_args[3]);
   
         cpu_reset_address = fdt_reset;          cpu_reset_address = fdt_reset;
         cpu_powerdown_address = fdt_powerdown;          cpu_powerdown_address = fdt_powerdown;
         evbarm_device_register = fdt_device_register;          evbarm_device_register = fdt_device_register;
           evbarm_device_register_post_config = fdt_device_register_post_config;
           evbarm_cpu_rootconf = fdt_cpu_rootconf;
   
         /* Talk to the user */          /* Talk to the user */
         DPRINTF("\nNetBSD/evbarm (fdt) booting ...\n");          printf("NetBSD/evbarm (fdt) booting ...\n");
   
 #ifdef BOOT_ARGS  #ifdef BOOT_ARGS
         char mi_bootargs[] = BOOT_ARGS;          char mi_bootargs[] = BOOT_ARGS;
         parse_mi_bootargs(mi_bootargs);          parse_mi_bootargs(mi_bootargs);
 #endif  #endif
   
         DPRINTF("KERNEL_BASE=0x%x, "          fdt_get_memory(&memory_start, &memory_end);
                 "KERNEL_VM_BASE=0x%x, "  
                 "KERNEL_VM_BASE - KERNEL_BASE=0x%x, "  
                 "KERNEL_BASE_VOFFSET=0x%x\n",  
                 KERNEL_BASE,  
                 KERNEL_VM_BASE,  
                 KERNEL_VM_BASE - KERNEL_BASE,  
                 KERNEL_BASE_VOFFSET);  
   
         fdt_get_memory(&memory_addr, &memory_size);  
   
 #if !defined(_LP64)  #if !defined(_LP64)
         /* Cannot map memory above 4GB */          /* Cannot map memory above 4GB */
         if (memory_addr + memory_size > 0x100000000)          if (memory_end >= 0x100000000ULL)
                 memory_size = 0x100000000 - memory_addr;                  memory_end = 0x100000000ULL - PAGE_SIZE;
   
 #endif  #endif
           uint64_t memory_size = memory_end - memory_start;
   
         ram_size = (bus_size_t)memory_size;          VPRINTF("%s: memory start %" PRIx64 " end %" PRIx64 " (len %"
               PRIx64 ")\n", __func__, memory_start, memory_end, memory_size);
   
 #ifdef __HAVE_MM_MD_DIRECT_MAPPED_PHYS          /* Parse ramdisk info */
         const bool mapallmem_p = true;          fdt_probe_initrd(&initrd_start, &initrd_end);
 #ifndef PMAP_NEED_ALLOC_POOLPAGE  
         if (ram_size > KERNEL_VM_BASE - KERNEL_BASE) {  
                 DPRINTF("%s: dropping RAM size from %luMB to %uMB\n",  
                     __func__, (unsigned long) (ram_size >> 20),  
                     (KERNEL_VM_BASE - KERNEL_BASE) >> 20);  
                 ram_size = KERNEL_VM_BASE - KERNEL_BASE;  
         }  
 #endif  
 #else  
         const bool mapallmem_p = false;  
 #endif  
   
         /* Fake bootconfig structure for the benefit of pmap.c. */          /* Parse rndseed */
         bootconfig.dramblocks = 1;          fdt_probe_rndseed(&rndseed_start, &rndseed_end);
         bootconfig.dram[0].address = (bus_addr_t)memory_addr;  
         bootconfig.dram[0].pages = ram_size / PAGE_SIZE;  
   
         arm32_bootmem_init(bootconfig.dram[0].address, ram_size,          /*
             KERNEL_BASE_PHYS);           * Populate bootconfig structure for the benefit of
         arm32_kernel_vm_init(KERNEL_VM_BASE, ARM_VECTORS_HIGH, 0,           * dodumpsys
             plat->devmap(), mapallmem_p);           */
           VPRINTF("%s: fdt_build_bootconfig\n", __func__);
           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 */
           cpu_kernel_vm_init(memory_start, memory_size);
   
         DPRINTF("bootargs: %s\n", bootargs);          VPRINTF("bootargs: %s\n", bootargs);
   
         parse_mi_bootargs(boot_args);          parse_mi_bootargs(boot_args);
   
 #ifdef PMAP_NEED_ALLOC_POOLPAGE          VPRINTF("Memory regions:\n");
         bp_lowgig.bp_start = memory_addr / NBPG;          fdt_memory_foreach(fdt_add_boot_physmem, &memory_size);
         if (atop(ram_size) > bp_lowgig.bp_pages) {  
                 arm_poolpage_vmfreelist = bp_lowgig.bp_freelist;          u_int sp = initarm_common(KERNEL_VM_BASE, KERNEL_VM_SIZE, fdt_physmem,
                 return initarm_common(KERNEL_VM_BASE, KERNEL_VM_SIZE,               nfdt_physmem);
                     &bp_lowgig, 1);  
           /*
            * initarm_common flushes cache if required before AP start
            */
           error = 0;
           if ((boothowto & RB_MD1) == 0) {
                   VPRINTF("mpstart\n");
                   if (plat->ap_mpstart)
                           error = plat->ap_mpstart();
         }          }
 #endif  
   
         return initarm_common(KERNEL_VM_BASE, KERNEL_VM_SIZE, NULL, 0);          if (error)
                   return sp;
           /*
            * Now we have APs started the pages used for stacks and L1PT can
            * be given to uvm
            */
           extern char const __start__init_memory[];
           extern char const __stop__init_memory[] __weak;
   
           if (__start__init_memory != __stop__init_memory) {
                   const paddr_t spa = KERN_VTOPHYS((vaddr_t)__start__init_memory);
                   const paddr_t epa = KERN_VTOPHYS((vaddr_t)__stop__init_memory);
                   const paddr_t spg = atop(spa);
                   const paddr_t epg = atop(epa);
   
                   uvm_page_physload(spg, epg, spg, epg, VM_FREELIST_DEFAULT);
   
                   VPRINTF("           start %08lx  end %08lx", ptoa(spa), ptoa(epa));
           }
   
           return sp;
 }  }
   
 static void  static void
Line 336  consinit(void)
Line 681  consinit(void)
         if (initialized || cons == NULL)          if (initialized || cons == NULL)
                 return;                  return;
   
         plat->init_attach_args(&faa);          plat->ap_init_attach_args(&faa);
         faa.faa_phandle = fdtbus_get_stdout_phandle();          faa.faa_phandle = fdtbus_get_stdout_phandle();
   
         if (plat->uart_freq != NULL)          if (plat->ap_uart_freq != NULL)
                 uart_freq = plat->uart_freq();                  uart_freq = plat->ap_uart_freq();
   
         cons->consinit(&faa, uart_freq);          cons->consinit(&faa, uart_freq);
   
Line 348  consinit(void)
Line 693  consinit(void)
 }  }
   
 void  void
   cpu_startup_hook(void)
   {
   
           fdtbus_intr_init();
   
           fdt_setup_rndseed();
   }
   
   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();
   
         plat->delay(us);          plat->ap_delay(us);
   }
   
   static void
   fdt_detect_root_device(device_t dev)
   {
           struct mbr_sector mbr;
           uint8_t buf[DEV_BSIZE];
           uint8_t hash[16];
           const uint8_t *rhash;
           char rootarg[64];
           struct vnode *vp;
           MD5_CTX md5ctx;
           int error, len;
           size_t resid;
           u_int part;
   
           const int chosen = OF_finddevice("/chosen");
           if (chosen < 0)
                   return;
   
           if (of_hasprop(chosen, "netbsd,mbr") &&
               of_hasprop(chosen, "netbsd,partition")) {
   
                   /*
                    * The bootloader has passed in a partition index and MD5 hash
                    * of the MBR sector. Read the MBR of this device, calculate the
                    * hash, and compare it with the value passed in.
                    */
                   rhash = fdtbus_get_prop(chosen, "netbsd,mbr", &len);
                   if (rhash == NULL || len != 16)
                           return;
                   of_getprop_uint32(chosen, "netbsd,partition", &part);
                   if (part >= MAXPARTITIONS)
                           return;
   
                   vp = opendisk(dev);
                   if (!vp)
                           return;
                   error = vn_rdwr(UIO_READ, vp, buf, sizeof(buf), 0, UIO_SYSSPACE,
                       0, NOCRED, &resid, NULL);
                   VOP_CLOSE(vp, FREAD, NOCRED);
                   vput(vp);
   
                   if (error != 0)
                           return;
   
                   memcpy(&mbr, buf, sizeof(mbr));
                   MD5Init(&md5ctx);
                   MD5Update(&md5ctx, (void *)&mbr, sizeof(mbr));
                   MD5Final(hash, &md5ctx);
   
                   if (memcmp(rhash, hash, 16) != 0)
                           return;
   
                   snprintf(rootarg, sizeof(rootarg), " root=%s%c", device_xname(dev), part + 'a');
                   strcat(boot_args, rootarg);
           }
   
           if (of_hasprop(chosen, "netbsd,gpt-guid")) {
                   char guidbuf[UUID_STR_LEN];
                   const struct uuid *guid = fdtbus_get_prop(chosen, "netbsd,gpt-guid", &len);
                   if (guid == NULL || len != 16)
                           return;
   
                   uuid_snprintf(guidbuf, sizeof(guidbuf), guid);
                   snprintf(rootarg, sizeof(rootarg), " root=wedge:%s", guidbuf);
                   strcat(boot_args, rootarg);
           }
   
           if (of_hasprop(chosen, "netbsd,gpt-label")) {
                   const char *label = fdtbus_get_string(chosen, "netbsd,gpt-label");
                   if (label == NULL || *label == '\0')
                           return;
   
                   device_t dv = dkwedge_find_by_wname(label);
                   if (dv != NULL)
                           booted_device = dv;
           }
   
           if (of_hasprop(chosen, "netbsd,booted-mac-address")) {
                   const uint8_t *macaddr = fdtbus_get_prop(chosen, "netbsd,booted-mac-address", &len);
                   if (macaddr == NULL || len != 6)
                           return;
                   int s = pserialize_read_enter();
                   struct ifnet *ifp;
                   IFNET_READER_FOREACH(ifp) {
                           if (memcmp(macaddr, CLLADDR(ifp->if_sadl), len) == 0) {
                                   device_t dv = device_find_by_xname(ifp->if_xname);
                                   if (dv != NULL)
                                           booted_device = dv;
                                   break;
                           }
                   }
                   pserialize_read_exit(s);
           }
 }  }
   
 static void  static void
Line 360  fdt_device_register(device_t self, void 
Line 809  fdt_device_register(device_t self, void 
 {  {
         const struct arm_platform *plat = arm_fdt_platform();          const struct arm_platform *plat = arm_fdt_platform();
   
         if (plat && plat->device_register)          if (device_is_a(self, "armfdt"))
                 plat->device_register(self, aux);                  fdt_setup_initrd();
   
           if (plat && plat->ap_device_register)
                   plat->ap_device_register(self, aux);
   }
   
   static void
   fdt_device_register_post_config(device_t self, void *aux)
   {
   #if NUKBD > 0 && NWSDISPLAY > 0
           if (device_is_a(self, "wsdisplay")) {
                   struct wsdisplay_softc *sc = device_private(self);
                   if (wsdisplay_isconsole(sc))
                           ukbd_cnattach();
           }
   #endif
   }
   
   static void
   fdt_cpu_rootconf(void)
   {
           device_t dev;
           deviter_t di;
           char *ptr;
   
           for (dev = deviter_first(&di, 0); dev; dev = deviter_next(&di)) {
                   if (device_class(dev) != DV_DISK)
                           continue;
   
                   if (get_bootconf_option(boot_args, "root", BOOTOPT_TYPE_STRING, &ptr) != 0)
                           break;
   
                   if (device_is_a(dev, "ld") || device_is_a(dev, "sd") || device_is_a(dev, "wd"))
                           fdt_detect_root_device(dev);
           }
           deviter_release(&di);
 }  }
   
 static void  static void
Line 371  fdt_reset(void)
Line 855  fdt_reset(void)
   
         fdtbus_power_reset();          fdtbus_power_reset();
   
         if (plat && plat->reset)          if (plat && plat->ap_reset)
                 plat->reset();                  plat->ap_reset();
 }  }
   
 static void  static void
Legend:
Removed from v.1.7  
changed lines
  Added in v.1.24.2.2
CVSweb <webmaster@jp.NetBSD.org>