Home | History | Annotate | Line # | Download | only in mini2440
      1 /*-
      2  * Copyright (c) 2012 The NetBSD Foundation, Inc.
      3  * All rights reserved.
      4  *
      5  * This code is derived from software contributed to The NetBSD Foundation
      6  * by Paul Fleischer <paul (at) xpg.dk>
      7  *
      8  * Redistribution and use in source and binary forms, with or without
      9  * modification, are permitted provided that the following conditions
     10  * are met:
     11  * 1. Redistributions of source code must retain the above copyright
     12  *    notice, this list of conditions and the following disclaimer.
     13  * 2. Redistributions in binary form must reproduce the above copyright
     14  *    notice, this list of conditions and the following disclaimer in the
     15  *    documentation and/or other materials provided with the distribution.
     16  *
     17  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     18  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     20  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     21  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     22  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     23  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     25  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     26  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     27  * POSSIBILITY OF SUCH DAMAGE.
     28  */
     29 /* This file is based on arch/evbarm/smdk2xx0/smdk2410_machdep.c */
     30 /*
     31  * Copyright (c) 2002, 2003 Fujitsu Component Limited
     32  * Copyright (c) 2002, 2003, 2005 Genetec Corporation
     33  * All rights reserved.
     34  *
     35  * Redistribution and use in source and binary forms, with or without
     36  * modification, are permitted provided that the following conditions
     37  * are met:
     38  * 1. Redistributions of source code must retain the above copyright
     39  *    notice, this list of conditions and the following disclaimer.
     40  * 2. Redistributions in binary form must reproduce the above copyright
     41  *    notice, this list of conditions and the following disclaimer in the
     42  *    documentation and/or other materials provided with the distribution.
     43  * 3. Neither the name of The Fujitsu Component Limited nor the name of
     44  *    Genetec corporation may not be used to endorse or promote products
     45  *    derived from this software without specific prior written permission.
     46  *
     47  * THIS SOFTWARE IS PROVIDED BY FUJITSU COMPONENT LIMITED AND GENETEC
     48  * CORPORATION ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
     49  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     50  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     51  * DISCLAIMED.  IN NO EVENT SHALL FUJITSU COMPONENT LIMITED OR GENETEC
     52  * CORPORATION BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     53  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     54  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
     55  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
     56  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
     57  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
     58  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     59  * SUCH DAMAGE.
     60  */
     61 /*
     62  * Copyright (c) 2001,2002 ARM Ltd
     63  * All rights reserved.
     64  *
     65  * Redistribution and use in source and binary forms, with or without
     66  * modification, are permitted provided that the following conditions
     67  * are met:
     68  * 1. Redistributions of source code must retain the above copyright
     69  *    notice, this list of conditions and the following disclaimer.
     70  * 2. Redistributions in binary form must reproduce the above copyright
     71  *    notice, this list of conditions and the following disclaimer in the
     72  *    documentation and/or other materials provided with the distribution.
     73  * 3. The name of the company may not be used to endorse or promote
     74  *    products derived from this software without specific prior written
     75  *    permission.
     76  *
     77  * THIS SOFTWARE IS PROVIDED BY ARM LTD ``AS IS'' AND
     78  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     79  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     80  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ARM LTD
     81  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     82  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     83  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     84  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     85  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     86  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     87  * POSSIBILITY OF SUCH DAMAGE.
     88  *
     89  */
     90 
     91 /*
     92  * Copyright (c) 1997,1998 Mark Brinicombe.
     93  * Copyright (c) 1997,1998 Causality Limited.
     94  * All rights reserved.
     95  *
     96  * Redistribution and use in source and binary forms, with or without
     97  * modification, are permitted provided that the following conditions
     98  * are met:
     99  * 1. Redistributions of source code must retain the above copyright
    100  *    notice, this list of conditions and the following disclaimer.
    101  * 2. Redistributions in binary form must reproduce the above copyright
    102  *    notice, this list of conditions and the following disclaimer in the
    103  *    documentation and/or other materials provided with the distribution.
    104  * 3. All advertising materials mentioning features or use of this software
    105  *    must display the following acknowledgement:
    106  *	This product includes software developed by Mark Brinicombe
    107  *	for the NetBSD Project.
    108  * 4. The name of the company nor the name of the author may be used to
    109  *    endorse or promote products derived from this software without specific
    110  *    prior written permission.
    111  *
    112  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
    113  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
    114  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
    115  * IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
    116  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
    117  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
    118  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    119  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    120  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
    121  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    122  * SUCH DAMAGE.
    123  *
    124  * Machine dependant functions for kernel setup for integrator board
    125  *
    126  * Created      : 24/11/97
    127  */
    128 
    129 /*
    130  * Machine dependant functions for kernel setup for FriendlyARM MINI2440
    131  */
    132 
    133 #include <sys/cdefs.h>
    134 __KERNEL_RCSID(0, "$NetBSD: mini2440_machdep.c,v 1.22 2024/02/20 23:36:02 andvar Exp $");
    135 
    136 #include "opt_arm_debug.h"
    137 #include "opt_console.h"
    138 #include "opt_ddb.h"
    139 #include "opt_kgdb.h"
    140 #include "opt_md.h"
    141 
    142 #include <sys/param.h>
    143 #include <sys/device.h>
    144 #include <sys/systm.h>
    145 #include <sys/kernel.h>
    146 #include <sys/exec.h>
    147 #include <sys/proc.h>
    148 #include <sys/msgbuf.h>
    149 #include <sys/reboot.h>
    150 #include <sys/termios.h>
    151 #include <sys/ksyms.h>
    152 #include <sys/mount.h>
    153 
    154 #include <net/if.h>
    155 #include <net/if_ether.h>
    156 #include <net/if_media.h>
    157 
    158 #include <uvm/uvm_extern.h>
    159 
    160 #include <dev/cons.h>
    161 #include <dev/md.h>
    162 
    163 #include <machine/db_machdep.h>
    164 #include <ddb/db_sym.h>
    165 #include <ddb/db_extern.h>
    166 #ifdef KGDB
    167 #include <sys/kgdb.h>
    168 #endif
    169 
    170 #include <sys/exec_elf.h>
    171 
    172 #include <sys/bus.h>
    173 #include <machine/cpu.h>
    174 #include <machine/frame.h>
    175 #include <machine/intr.h>
    176 #include <arm/undefined.h>
    177 
    178 #include <machine/autoconf.h>
    179 
    180 #include <arm/locore.h>
    181 #include <arm/arm32/machdep.h>
    182 
    183 #include <arm/s3c2xx0/s3c2440reg.h>
    184 #include <arm/s3c2xx0/s3c2440var.h>
    185 
    186 #include <arch/evbarm/mini2440/mini2440_bootinfo.h>
    187 
    188 #include "ksyms.h"
    189 
    190 #ifndef	SDRAM_START
    191 #define	SDRAM_START	S3C2440_SDRAM_START
    192 #endif
    193 #ifndef	SDRAM_SIZE
    194 #define	SDRAM_SIZE	(64*1024*1024) /* 64 Mb */
    195 #endif
    196 
    197 /*
    198  * Address to map I/O registers in early initialize stage.
    199  */
    200 #define MINI2440_IO_VBASE	0xfd000000
    201 
    202 /* Kernel text starts 2MB in from the bottom of the kernel address space. */
    203 #define KERNEL_OFFSET		0x00200000
    204 #define	KERNEL_TEXT_BASE	(KERNEL_BASE + KERNEL_OFFSET)
    205 #define	KERNEL_VM_BASE		(KERNEL_BASE + 0x01000000)
    206 
    207 /*
    208  * The range 0xc1000000 - 0xccffffff is available for kernel VM space
    209  * Core-logic registers and I/O mappings occupy 0xfd000000 - 0xffffffff
    210  */
    211 #define KERNEL_VM_SIZE		0x0C000000
    212 
    213 /* Declared extern elsewhere in the kernel */
    214 BootConfig bootconfig;		/* Boot config storage */
    215 char *boot_args = NULL;
    216 //char *boot_file = NULL;
    217 
    218 char bootinfo[BOOTINFO_MAXSIZE];
    219 struct btinfo_rootdevice 	*bi_rdev;
    220 struct btinfo_net		*bi_net;
    221 struct btinfo_bootpath		*bi_path;
    222 
    223 vaddr_t physical_start;
    224 vaddr_t physical_freestart;
    225 vaddr_t physical_freeend;
    226 vaddr_t physical_freeend_low;
    227 vaddr_t physical_end;
    228 u_int free_pages;
    229 vaddr_t pagetables_start;
    230 
    231 /*int debug_flags;*/
    232 #ifndef PMAP_STATIC_L1S
    233 int max_processes = 64;		/* Default number */
    234 #endif				/* !PMAP_STATIC_L1S */
    235 
    236 paddr_t msgbufphys;
    237 
    238 #define KERNEL_PT_SYS		0	/* L2 table for mapping zero page */
    239 #define KERNEL_PT_KERNEL	1	/* L2 table for mapping kernel */
    240 #define KERNEL_PT_KERNEL_NUM	3	/* L2 tables for mapping kernel VM */
    241 
    242 #define KERNEL_PT_VMDATA	(KERNEL_PT_KERNEL + KERNEL_PT_KERNEL_NUM)
    243 
    244 #define KERNEL_PT_VMDATA_NUM	4	/* start with 16MB of KVM */
    245 #define NUM_KERNEL_PTS		(KERNEL_PT_VMDATA + KERNEL_PT_VMDATA_NUM)
    246 
    247 pv_addr_t kernel_pt_table[NUM_KERNEL_PTS];
    248 
    249 /* Prototypes */
    250 
    251 void consinit(void);
    252 void kgdb_port_init(void);
    253 static void mini2440_ksyms(struct btinfo_symtab *bi_symtab);
    254 static void *lookup_bootinfo(int type);
    255 static void mini2440_device_register(device_t dev, void *aux);
    256 
    257 
    258 #include "com.h"
    259 #if NCOM > 0
    260 #include <dev/ic/comreg.h>
    261 #include <dev/ic/comvar.h>
    262 #endif
    263 
    264 #include "sscom.h"
    265 #if NSSCOM > 0
    266 #include "opt_sscom.h"
    267 #include <arm/s3c2xx0/sscom_var.h>
    268 #endif
    269 
    270 /*
    271  * Define the default console speed for the board.  This is generally
    272  * what the firmware provided with the board defaults to.
    273  */
    274 #ifndef CONSPEED
    275 #define CONSPEED B115200	/* TTYDEF_SPEED */
    276 #endif
    277 #ifndef CONMODE
    278 #define CONMODE ((TTYDEF_CFLAG & ~(CSIZE | CSTOPB | PARENB)) | CS8)   /* 8N1 */
    279 #endif
    280 
    281 int comcnspeed = CONSPEED;
    282 int comcnmode = CONMODE;
    283 
    284 /*
    285  * void cpu_reboot(int howto, char *bootstr)
    286  *
    287  * Reboots the system
    288  *
    289  * Deal with any syncing, unmounting, dumping and shutdown hooks,
    290  * then reset the CPU.
    291  */
    292 void
    293 cpu_reboot(int howto, char *bootstr)
    294 {
    295 #ifdef DIAGNOSTIC
    296 	/* info */
    297 	printf("boot: howto=%08x curproc=%p\n", howto, curproc);
    298 #endif
    299 
    300 	cpu_reset_address_paddr = vtophys((uintptr_t)s3c2440_softreset);
    301 
    302 	/*
    303 	 * If we are still cold then hit the air brakes
    304 	 * and crash to earth fast
    305 	 */
    306 	if (cold) {
    307 		doshutdownhooks();
    308 		printf("The operating system has halted.\n");
    309 		printf("Please press any key to reboot.\n\n");
    310 		cngetc();
    311 		printf("rebooting...\n");
    312 		cpu_reset();
    313 		/* NOTREACHED */
    314 	}
    315 	/* Disable console buffering */
    316 
    317 	/*
    318 	 * If RB_NOSYNC was not specified sync the discs.
    319 	 * Note: Unless cold is set to 1 here, syslogd will die during the
    320 	 * unmount.  It looks like syslogd is getting woken up only to find
    321 	 * that it cannot page part of the binary in as the filesystem has
    322 	 * been unmounted.
    323 	 */
    324 	if (!(howto & RB_NOSYNC))
    325 		bootsync();
    326 
    327 	/* Say NO to interrupts */
    328 	splhigh();
    329 
    330 	/* Do a dump if requested. */
    331 	if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
    332 		dumpsys();
    333 
    334 	/* Run any shutdown hooks */
    335 	doshutdownhooks();
    336 
    337 	/* Make sure IRQ's are disabled */
    338 	IRQdisable;
    339 
    340 	if (howto & RB_HALT) {
    341 		printf("The operating system has halted.\n");
    342 		printf("Please press any key to reboot.\n\n");
    343 		cngetc();
    344 	}
    345 	printf("rebooting...\n");
    346 	cpu_reset();
    347 	/* NOTREACHED */
    348 }
    349 
    350 /*
    351  * Static device mappings. These peripheral registers are mapped at
    352  * fixed virtual addresses very early in initarm() so that we can use
    353  * them while booting the kernel , and stay at the same address
    354  * throughout whole kernel's life time.
    355  *
    356  * We use this table twice; once with bootstrap page table, and once
    357  * with kernel's page table which we build up in initarm().
    358  *
    359  * Since we map these registers into the bootstrap page table using
    360  * pmap_devmap_bootstrap() which calls pmap_map_chunk(), we map
    361  * registers segment-aligned and segment-rounded in order to avoid
    362  * using the 2nd page tables.
    363  */
    364 
    365 #define	_V(n)	(MINI2440_IO_VBASE + (n) * L1_S_SIZE)
    366 
    367 #define	GPIO_VBASE	_V(0)
    368 #define	INTCTL_VBASE	_V(1)
    369 #define	CLKMAN_VBASE	_V(2)
    370 #define	UART_VBASE	_V(3)
    371 
    372 static const struct pmap_devmap mini2440_devmap[] = {
    373 	/* GPIO registers */
    374 	DEVMAP_ENTRY(
    375 		GPIO_VBASE,
    376 		S3C2440_GPIO_BASE,
    377 		S3C2440_GPIO_SIZE
    378 	),
    379 	DEVMAP_ENTRY(
    380 		INTCTL_VBASE,
    381 		S3C2440_INTCTL_BASE,
    382 		S3C2440_INTCTL_SIZE
    383 	),
    384 	DEVMAP_ENTRY(
    385 		CLKMAN_VBASE,
    386 		S3C2440_CLKMAN_BASE,
    387 		S3C24X0_CLKMAN_SIZE
    388 	),
    389 	/* UART registers for UART0, 1, 2. */
    390 	DEVMAP_ENTRY(
    391 		UART_VBASE,
    392 		S3C2440_UART0_BASE,
    393 		S3C2440_UART_BASE(3) - S3C2440_UART0_BASE
    394 	),
    395 	DEVMAP_ENTRY_END
    396 };
    397 
    398 static inline	pd_entry_t *
    399 read_ttb(void)
    400 {
    401 	long ttb;
    402 
    403 	__asm volatile("mrc	p15, 0, %0, c2, c0, 0" : "=r"(ttb));
    404 
    405 
    406 	return (pd_entry_t *)(ttb & ~((1 << 14) - 1));
    407 }
    408 
    409 
    410 #define	ioreg_write32(a,v)  	(*(volatile uint32_t *)(a)=(v))
    411 
    412 /*
    413  * vaddr_t initarm(...)
    414  *
    415  * Initial entry point on startup. This gets called before main() is
    416  * entered.
    417  * It should be responsible for setting up everything that must be
    418  * in place when main is called.
    419  * This includes
    420  *   Taking a copy of the boot configuration structure.
    421  *   Initialising the physical console so characters can be printed.
    422  *   Setting up page tables for the kernel
    423  *   Relocating the kernel to the bottom of physical memory
    424  */
    425 
    426 vaddr_t
    427 initarm(void *arg)
    428 {
    429 	int loop;
    430 	int loop1;
    431 	u_int l1pagetable;
    432 	extern int etext __asm("_etext");
    433 	extern int end __asm("_end");
    434 	uint32_t kerneldatasize;
    435 	struct btinfo_magic *bi_magic = arg;
    436 	struct btinfo_bootstring *bi_bootstring;
    437 	struct btinfo_symtab *bi_symtab;
    438 
    439 	boothowto = 0;
    440 
    441 	/* Copy bootinfo from boot loader into kernel memory where it remains.
    442 	 */
    443 	if (bi_magic != 0x0 && bi_magic->magic == BOOTINFO_MAGIC) {
    444 		memcpy(bootinfo, bi_magic, sizeof(bootinfo));
    445 	} else {
    446 		memset(bootinfo, 0, sizeof(bootinfo));
    447 	}
    448 
    449 	/* Extract boot_args from bootinfo */
    450 	bi_bootstring = lookup_bootinfo(BTINFO_BOOTSTRING);
    451 	if (bi_bootstring ) {
    452 		printf("Bootloader args are %s\n", bi_bootstring->bootstring);
    453 		boot_args = bi_bootstring->bootstring;
    454 		parse_mi_bootargs(boot_args);
    455 	}
    456 
    457 #define pdatb (*(volatile uint8_t *)(S3C2440_GPIO_BASE+GPIO_PBDAT))
    458 
    459 // 0x1E0 is the mask for GPB5, GPB6, GPB7, and GPB8
    460 #define __LED(x)  (pdatb = (pdatb & ~0x1e0) | (~(1<<(x+5)) & 0x1e0))
    461 
    462 	__LED(0);
    463 
    464 	/*
    465 	 * Heads up ... Setup the CPU / MMU / TLB functions
    466 	 */
    467 	if (set_cpufuncs())
    468 		panic("cpu not recognized!");
    469 
    470 	/*
    471 	 * Map I/O registers that are used in startup.  Now we are
    472 	 * still using page table prepared by bootloader.  Later we'll
    473 	 * map those registers at the same address in the kernel page
    474 	 * table.
    475 	 */
    476 	pmap_devmap_bootstrap((vaddr_t)read_ttb(), mini2440_devmap);
    477 
    478 #undef	pdatb
    479 #define pdatb (*(volatile uint8_t *)(GPIO_VBASE+GPIO_PBDAT))
    480 
    481 	/* Disable all peripheral interrupts */
    482 	ioreg_write32(INTCTL_VBASE + INTCTL_INTMSK, ~0);
    483 
    484 	__LED(1);
    485 
    486 	/* initialize some variables so that splfoo() doesn't
    487 	   touch illegal address.  */
    488 	s3c2xx0_intr_bootstrap(INTCTL_VBASE);
    489 
    490 	__LED(2);
    491 	consinit();
    492 	__LED(3);
    493 
    494 	/* Extract information from the bootloader configuration */
    495 	bi_rdev = lookup_bootinfo(BTINFO_ROOTDEVICE);
    496 	bi_net = lookup_bootinfo(BTINFO_NET);
    497 	bi_path = lookup_bootinfo(BTINFO_BOOTPATH);
    498 
    499 #ifdef VERBOSE_INIT_ARM
    500 	printf("consinit done\n");
    501 #endif
    502 
    503 #ifdef KGDB
    504 	kgdb_port_init();
    505 #endif
    506 
    507 #ifdef VERBOSE_INIT_ARM
    508 	/* Talk to the user */
    509 	printf("\nNetBSD/evbarm (MINI2440) booting ...\n");
    510 #endif
    511 	/*
    512 	 * Ok we have the following memory map
    513 	 *
    514 	 * Physical Address Range     Description
    515 	 * -----------------------    ----------------------------------
    516 	 * 0x30000000 - 0x33ffffff    SDRAM (64MB)
    517          *
    518          * Kernel is loaded by bootloader at 0x30200000
    519 	 *
    520 	 * The initarm() has the responsibility for creating the kernel
    521 	 * page tables.
    522 	 * It must also set up various memory pointers that are used
    523 	 * by pmap etc.
    524 	 */
    525 
    526 	/* Fake bootconfig structure for the benefit of pmap.c */
    527 	/* XXX must make the memory description h/w independent */
    528 	bootconfig.dramblocks = 1;
    529 	bootconfig.dram[0].address = SDRAM_START;
    530 	bootconfig.dram[0].pages = SDRAM_SIZE / PAGE_SIZE;
    531 
    532 	/*
    533 	 * Set up the variables that define the availability of
    534 	 * physical memory.
    535          * We use the 2MB between the physical start and the kernel to
    536          * begin with. Allocating from 0x30200000 and downwards
    537 	 * If we get too close to the bottom of SDRAM, we
    538 	 * will panic.  We will update physical_freestart and
    539 	 * physical_freeend later to reflect what pmap_bootstrap()
    540 	 * wants to see.
    541 	 *
    542 	 * XXX pmap_bootstrap() needs an enema.
    543 	 */
    544 	physical_start = bootconfig.dram[0].address;
    545 	physical_end = physical_start + (bootconfig.dram[0].pages * PAGE_SIZE);
    546 
    547 	physical_freestart = SDRAM_START;	/* XXX */
    548 	physical_freeend = SDRAM_START + KERNEL_OFFSET;
    549 
    550 	physmem = (physical_end - physical_start) / PAGE_SIZE;
    551 
    552 #ifdef VERBOSE_INIT_ARM
    553 	/* Tell the user about the memory */
    554 	printf("physmemory: 0x%"PRIxPSIZE" pages at 0x%08lx -> 0x%08lx\n", physmem,
    555 	    physical_start, physical_end - 1);
    556 	printf("phys_end: 0x%08lx\n", physical_end);
    557 #endif
    558 
    559 	/*
    560 	 * XXX
    561 	 * Okay, the kernel starts 2MB in from the bottom of physical
    562 	 * memory.  We are going to allocate our bootstrap pages downwards
    563 	 * from there.
    564 	 *
    565 	 * We need to allocate some fixed page tables to get the kernel
    566 	 * going.  We allocate one page directory and a number of page
    567 	 * tables and store the physical addresses in the kernel_pt_table
    568 	 * array.
    569 	 *
    570 	 * The kernel page directory must be on a 16K boundary.  The page
    571 	 * tables must be on 4K boundaries.  What we do is allocate the
    572 	 * page directory on the first 16K boundary that we encounter, and
    573 	 * the page tables on 4K boundaries otherwise.  Since we allocate
    574 	 * at least 3 L2 page tables, we are guaranteed to encounter at
    575 	 * least one 16K aligned region.
    576 	 */
    577 
    578 #ifdef VERBOSE_INIT_ARM
    579 	printf("Allocating page tables\n");
    580 #endif
    581 
    582 	free_pages = (physical_freeend - physical_freestart) / PAGE_SIZE;
    583 
    584 #ifdef VERBOSE_INIT_ARM
    585 	printf("freestart = 0x%08lx, free_pages = %d (0x%08x), freeend = 0x%08lx\n",
    586 	    physical_freestart, free_pages, free_pages, physical_freeend);
    587 #endif
    588 
    589 	/* Define a macro to simplify memory allocation */
    590 #define	valloc_pages(var, np)				\
    591 	alloc_pages((var).pv_pa, (np));			\
    592 	(var).pv_va = KERNEL_BASE + (var).pv_pa - physical_start;
    593 
    594 #define alloc_pages(var, np)				\
    595 	physical_freeend -= ((np) * PAGE_SIZE);		\
    596 	if (physical_freeend < physical_freestart)	\
    597 		panic("initarm: out of memory");	\
    598 	(var) = physical_freeend;			\
    599 	free_pages -= (np);				\
    600 	memset((char *)(var), 0, ((np) * PAGE_SIZE));
    601 
    602 	loop1 = 0;
    603 	for (loop = 0; loop <= NUM_KERNEL_PTS; ++loop) {
    604 		/* Are we 16KB aligned for an L1 ? */
    605 		if (((physical_freeend - L1_TABLE_SIZE) & (L1_TABLE_SIZE - 1)) == 0
    606 		    && kernel_l1pt.pv_pa == 0) {
    607 			valloc_pages(kernel_l1pt, L1_TABLE_SIZE / PAGE_SIZE);
    608 		} else {
    609 			valloc_pages(kernel_pt_table[loop1],
    610 			    L2_TABLE_SIZE / PAGE_SIZE);
    611 			++loop1;
    612 		}
    613 	}
    614 
    615 	/* This should never be able to happen but better confirm that. */
    616 	if (!kernel_l1pt.pv_pa || (kernel_l1pt.pv_pa & (L1_TABLE_SIZE - 1)) != 0)
    617 		panic("initarm: Failed to align the kernel page directory\n");
    618 
    619 	/*
    620 	 * Allocate a page for the system page mapped to V0x00000000
    621 	 * This page will just contain the system vectors and can be
    622 	 * shared by all processes.
    623 	 */
    624 	alloc_pages(systempage.pv_pa, 1);
    625 
    626 	/* Allocate stacks for all modes */
    627 	valloc_pages(irqstack, IRQ_STACK_SIZE);
    628 	valloc_pages(abtstack, ABT_STACK_SIZE);
    629 	valloc_pages(undstack, UND_STACK_SIZE);
    630 	valloc_pages(kernelstack, UPAGES);
    631 
    632 #ifdef VERBOSE_INIT_ARM
    633 	printf("IRQ stack: p0x%08lx v0x%08lx\n", irqstack.pv_pa,
    634 	    irqstack.pv_va);
    635 	printf("ABT stack: p0x%08lx v0x%08lx\n", abtstack.pv_pa,
    636 	    abtstack.pv_va);
    637 	printf("UND stack: p0x%08lx v0x%08lx\n", undstack.pv_pa,
    638 	    undstack.pv_va);
    639 	printf("SVC stack: p0x%08lx v0x%08lx\n", kernelstack.pv_pa,
    640 	    kernelstack.pv_va);
    641 	printf("Free memory in bootstrap region: %ld bytes\n", physical_freeend - physical_freestart);
    642 #endif
    643 
    644 	alloc_pages(msgbufphys, round_page(MSGBUFSIZE) / PAGE_SIZE);
    645 
    646 	physical_freeend_low = physical_freeend;
    647 
    648 	/*
    649 	 * Ok we have allocated physical pages for the primary kernel
    650 	 * page tables
    651 	 */
    652 
    653 #ifdef VERBOSE_INIT_ARM
    654 	printf("Creating L1 page table at 0x%08lx\n", kernel_l1pt.pv_pa);
    655 #endif
    656 
    657 	/*
    658 	 * Now we start construction of the L1 page table
    659 	 * We start by mapping the L2 page tables into the L1.
    660 	 * This means that we can replace L1 mappings later on if necessary
    661 	 */
    662 	l1pagetable = kernel_l1pt.pv_pa;
    663 
    664 	/* Map the L2 pages tables in the L1 page table */
    665 	pmap_link_l2pt(l1pagetable, 0x00000000,
    666 	    &kernel_pt_table[KERNEL_PT_SYS]);
    667 	for (loop = 0; loop < KERNEL_PT_KERNEL_NUM; loop++)
    668 		pmap_link_l2pt(l1pagetable, KERNEL_BASE + loop * 0x00400000,
    669 		    &kernel_pt_table[KERNEL_PT_KERNEL + loop]);
    670 	for (loop = 0; loop < KERNEL_PT_VMDATA_NUM; loop++)
    671 		pmap_link_l2pt(l1pagetable, KERNEL_VM_BASE + loop * 0x00400000,
    672 		    &kernel_pt_table[KERNEL_PT_VMDATA + loop]);
    673 
    674 	/* update the top of the kernel VM */
    675 	pmap_curmaxkvaddr =
    676 	    KERNEL_VM_BASE + (KERNEL_PT_VMDATA_NUM * 0x00400000);
    677 
    678 #ifdef VERBOSE_INIT_ARM
    679 	printf("Mapping kernel\n");
    680 #endif
    681 
    682 	/* Now we fill in the L2 pagetable for the kernel static code/data */
    683 	{
    684 		/* Total size must include symbol table, if it exists.
    685 		   The size of the symbol table can be acquired from the ELF
    686 		   header, to which a pointer is passed in the boot info (ssym).
    687 		 */
    688 		size_t textsize = (uintptr_t)&etext - KERNEL_TEXT_BASE;
    689 		kerneldatasize = (uintptr_t)&end - KERNEL_TEXT_BASE;
    690 		u_int logical;
    691 
    692 		bi_symtab = lookup_bootinfo(BTINFO_SYMTAB);
    693 
    694 		if (bi_symtab) {
    695 			Elf_Ehdr *elfHeader;
    696 			Elf_Shdr *sectionHeader;
    697 			int nsection;
    698 			int sz = 0;
    699 
    700 			elfHeader = bi_symtab->ssym;
    701 
    702 #ifdef VERBOSE_INIT_ARM
    703 			printf("Symbol table information provided by bootloader\n");
    704 			printf("ELF header is at %p\n", elfHeader);
    705 #endif
    706 			sectionHeader = (Elf_Shdr*)((char*)(bi_symtab->ssym) +
    707 						     (elfHeader->e_shoff));
    708 			nsection = elfHeader->e_shnum;
    709 #ifdef VERBOSE_INIT_ARM
    710 			printf("Number of sections: %d\n", nsection);
    711 #endif
    712 			for(; nsection > 0; nsection--, sectionHeader++) {
    713 				if (sectionHeader->sh_offset > 0 &&
    714 				    (sectionHeader->sh_offset + sectionHeader->sh_size) > sz)
    715 					sz = sectionHeader->sh_offset + sectionHeader->sh_size;
    716 			}
    717 #ifdef VERBOSE_INIT_ARM
    718 			printf("Max size of sections: %d\n", sz);
    719 #endif
    720 			kerneldatasize += sz;
    721 		}
    722 
    723 #ifdef VERBOSE_INIT_ARM
    724 		printf("Textsize: %u, kerneldatasize: %u\n", (uint)textsize,
    725 		       (uint)kerneldatasize);
    726 		printf("&etext: 0x%x\n", (uint)&etext);
    727 		printf("&end: 0x%x\n", (uint)&end);
    728 		printf("KERNEL_TEXT_BASE: 0x%x\n", KERNEL_TEXT_BASE);
    729 #endif
    730 
    731 		textsize = (textsize + PGOFSET) & ~PGOFSET;
    732 		kerneldatasize = (kerneldatasize + PGOFSET) & ~PGOFSET;
    733 
    734 		logical = KERNEL_OFFSET;	/* offset of kernel in RAM */
    735 
    736 		logical += pmap_map_chunk(l1pagetable, KERNEL_BASE + logical,
    737 					  physical_start + logical, textsize,
    738 					  VM_PROT_READ | VM_PROT_WRITE, PTE_CACHE);
    739 		logical += pmap_map_chunk(l1pagetable, KERNEL_BASE + logical,
    740 					  physical_start + logical, kerneldatasize - textsize,
    741 					  VM_PROT_READ | VM_PROT_WRITE, PTE_CACHE);
    742 	}
    743 
    744 #ifdef VERBOSE_INIT_ARM
    745 	printf("Constructing L2 page tables\n");
    746 #endif
    747 
    748 	/* Map the stack pages */
    749 	pmap_map_chunk(l1pagetable, irqstack.pv_va, irqstack.pv_pa,
    750 	    IRQ_STACK_SIZE * PAGE_SIZE, VM_PROT_READ | VM_PROT_WRITE,
    751 	    PTE_CACHE);
    752 	pmap_map_chunk(l1pagetable, abtstack.pv_va, abtstack.pv_pa,
    753 	    ABT_STACK_SIZE * PAGE_SIZE, VM_PROT_READ | VM_PROT_WRITE,
    754 	    PTE_CACHE);
    755 	pmap_map_chunk(l1pagetable, undstack.pv_va, undstack.pv_pa,
    756 	    UND_STACK_SIZE * PAGE_SIZE, VM_PROT_READ | VM_PROT_WRITE,
    757 	    PTE_CACHE);
    758 	pmap_map_chunk(l1pagetable, kernelstack.pv_va, kernelstack.pv_pa,
    759 	    UPAGES * PAGE_SIZE, VM_PROT_READ | VM_PROT_WRITE, PTE_CACHE);
    760 
    761 	pmap_map_chunk(l1pagetable, kernel_l1pt.pv_va, kernel_l1pt.pv_pa,
    762 	    L1_TABLE_SIZE, VM_PROT_READ | VM_PROT_WRITE, PTE_PAGETABLE);
    763 
    764 	for (loop = 0; loop < NUM_KERNEL_PTS; ++loop) {
    765 		pmap_map_chunk(l1pagetable, kernel_pt_table[loop].pv_va,
    766 		    kernel_pt_table[loop].pv_pa, L2_TABLE_SIZE,
    767 		    VM_PROT_READ|VM_PROT_WRITE, PTE_PAGETABLE);
    768 	}
    769 
    770 	/* Map the vector page. */
    771 #if 0
    772 	/* MULTI-ICE requires that page 0 is NC/NB so that it can download the
    773 	 * cache-clean code there.  */
    774 	pmap_map_entry(l1pagetable, vector_page, systempage.pv_pa,
    775 	    VM_PROT_READ | VM_PROT_WRITE, PTE_NOCACHE);
    776 #else
    777 	pmap_map_entry(l1pagetable, vector_page, systempage.pv_pa,
    778 	    VM_PROT_READ | VM_PROT_WRITE, PTE_CACHE);
    779 #endif
    780 
    781 	/*
    782 	 * map integrated peripherals at same address in l1pagetable
    783 	 * so that we can continue to use console.
    784 	 */
    785 	pmap_devmap_bootstrap(l1pagetable, mini2440_devmap);
    786 
    787 	/*
    788 	 * Now we have the real page tables in place so we can switch to them.
    789 	 * Once this is done we will be running with the REAL kernel page
    790 	 * tables.
    791 	 */
    792 	/*
    793 	 * Update the physical_freestart/physical_freeend/free_pages
    794 	 * variables.
    795 	 */
    796 	physical_freestart = physical_start +
    797 	  (KERNEL_TEXT_BASE - KERNEL_BASE) + kerneldatasize;
    798 	physical_freeend = physical_end;
    799 	free_pages =
    800 	  (physical_freeend - physical_freestart) / PAGE_SIZE;
    801 
    802 	/* Switch tables */
    803 #ifdef VERBOSE_INIT_ARM
    804 	printf("freestart = 0x%08lx, free_pages = %d (0x%x)\n",
    805 	    physical_freestart, free_pages, free_pages);
    806 	printf("switching to new L1 page table  @%#lx...", kernel_l1pt.pv_pa);
    807 #endif
    808 	cpu_domains((DOMAIN_CLIENT << (PMAP_DOMAIN_KERNEL*2)) | DOMAIN_CLIENT);
    809 	cpu_setttb(kernel_l1pt.pv_pa, true);
    810 	cpu_tlb_flushID();
    811 	cpu_domains(DOMAIN_CLIENT << (PMAP_DOMAIN_KERNEL*2));
    812 
    813 	/*
    814 	 * Moved from cpu_startup() as data_abort_handler() references
    815 	 * this during uvm init
    816 	 */
    817 	uvm_lwp_setuarea(&lwp0, kernelstack.pv_va);
    818 
    819 #ifdef VERBOSE_INIT_ARM
    820 	printf("done!\n");
    821 #endif
    822 
    823 #ifdef VERBOSE_INIT_ARM
    824 	printf("bootstrap done.\n");
    825 #endif
    826 
    827 	arm32_vector_init(ARM_VECTORS_LOW, ARM_VEC_ALL);
    828 
    829 	/*
    830 	 * Pages were allocated during the secondary bootstrap for the
    831 	 * stacks for different CPU modes.
    832 	 * We must now set the r13 registers in the different CPU modes to
    833 	 * point to these stacks.
    834 	 * Since the ARM stacks use STMFD etc. we must set r13 to the top end
    835 	 * of the stack memory.
    836 	 */
    837 #ifdef VERBOSE_INIT_ARM
    838 	printf("init subsystems: stacks ");
    839 #endif
    840 
    841 	set_stackptr(PSR_IRQ32_MODE,
    842 	    irqstack.pv_va + IRQ_STACK_SIZE * PAGE_SIZE);
    843 	set_stackptr(PSR_ABT32_MODE,
    844 	    abtstack.pv_va + ABT_STACK_SIZE * PAGE_SIZE);
    845 	set_stackptr(PSR_UND32_MODE,
    846 	    undstack.pv_va + UND_STACK_SIZE * PAGE_SIZE);
    847 
    848 	cpu_idcache_wbinv_all();
    849 
    850 	/*
    851 	 * Well we should set a data abort handler.
    852 	 * Once things get going this will change as we will need a proper
    853 	 * handler.
    854 	 * Until then we will use a handler that just panics but tells us
    855 	 * why.
    856 	 * Initialisation of the vectors will just panic on a data abort.
    857 	 * This just fills in a slightly better one.
    858 	 */
    859 #ifdef VERBOSE_INIT_ARM
    860 	printf("vectors ");
    861 #endif
    862 	data_abort_handler_address = (u_int)data_abort_handler;
    863 	prefetch_abort_handler_address = (u_int)prefetch_abort_handler;
    864 	undefined_handler_address = (u_int)undefinedinstruction_bounce;
    865 
    866 	/* Initialise the undefined instruction handlers */
    867 #ifdef VERBOSE_INIT_ARM
    868 	printf("undefined ");
    869 #endif
    870 	undefined_init();
    871 
    872 	/* Load memory into UVM. */
    873 #ifdef VERBOSE_INIT_ARM
    874 	printf("page ");
    875 #endif
    876 	uvm_md_init();
    877 	uvm_page_physload(atop(physical_freestart), atop(physical_freeend),
    878 	    atop(physical_freestart), atop(physical_freeend),
    879 	    VM_FREELIST_DEFAULT);
    880 	uvm_page_physload(atop(SDRAM_START), atop(physical_freeend_low),
    881 	    atop(SDRAM_START), atop(physical_freeend_low),
    882 	    VM_FREELIST_DEFAULT);
    883 
    884 
    885 	/* Boot strap pmap telling it where managed kernel virtual memory is */
    886 #ifdef VERBOSE_INIT_ARM
    887 	printf("pmap ");
    888 #endif
    889 	pmap_bootstrap(KERNEL_VM_BASE, KERNEL_VM_BASE + KERNEL_VM_SIZE);
    890 
    891 #ifdef VERBOSE_INIT_ARM
    892 	printf("done.\n");
    893 #endif
    894 
    895 #ifdef BOOTHOWTO
    896 	boothowto |= BOOTHOWTO;
    897 #endif
    898 
    899 #ifdef KGDB
    900 	if (boothowto & RB_KDB) {
    901 		kgdb_debug_init = 1;
    902 		kgdb_connect(1);
    903 	}
    904 #endif
    905 
    906 	mini2440_ksyms(bi_symtab);
    907 
    908 #ifdef DDB
    909 	/*db_machine_init();*/
    910 	if (boothowto & RB_KDB)
    911 		Debugger();
    912 #endif
    913 
    914 	evbarm_device_register = mini2440_device_register;
    915 
    916 	/* We return the new stack pointer address */
    917 	return kernelstack.pv_va + USPACE_SVC_STACK_TOP;
    918 }
    919 
    920 void
    921 consinit(void)
    922 {
    923 	static int consinit_done = 0;
    924 #if defined(SSCOM0CONSOLE) || defined(SSCOM1CONSOLE)
    925 	bus_space_tag_t iot = &s3c2xx0_bs_tag;
    926 #endif
    927 	int pclk;
    928 
    929 	if (consinit_done != 0)
    930 		return;
    931 
    932 	consinit_done = 1;
    933 
    934 	s3c24x0_clock_freq2(CLKMAN_VBASE, NULL, NULL, &pclk);
    935 
    936 #if NSSCOM > 0
    937 #ifdef SSCOM0CONSOLE
    938 	if (0 == s3c2440_sscom_cnattach(iot, 0, comcnspeed,
    939 		pclk, comcnmode))
    940 		return;
    941 #endif
    942 #ifdef SSCOM1CONSOLE
    943 	if (0 == s3c2440_sscom_cnattach(iot, 1, comcnspeed,
    944 		pclk, comcnmode))
    945 		return;
    946 #endif
    947 #endif				/* NSSCOM */
    948 #if NCOM>0 && defined(CONCOMADDR)
    949 	if (comcnattach(&isa_io_bs_tag, CONCOMADDR, comcnspeed,
    950 		COM_FREQ, COM_TYPE_NORMAL, comcnmode))
    951 		panic("can't init serial console @%x", CONCOMADDR);
    952 	return;
    953 #endif
    954 
    955 	consinit_done = 0;
    956 }
    957 
    958 
    959 #ifdef KGDB
    960 
    961 #if (NSSCOM > 0)
    962 
    963 #ifdef KGDB_DEVNAME
    964 const char kgdb_devname[] = KGDB_DEVNAME;
    965 #else
    966 const char kgdb_devname[] = "";
    967 #endif
    968 
    969 #ifndef KGDB_DEVMODE
    970 #define KGDB_DEVMODE ((TTYDEF_CFLAG & ~(CSIZE|CSTOPB|PARENB))|CS8) /* 8N1 */
    971 #endif
    972 int kgdb_sscom_mode = KGDB_DEVMODE;
    973 
    974 #endif				/* NSSCOM */
    975 
    976 void
    977 kgdb_port_init(void)
    978 {
    979 #if (NSSCOM > 0)
    980 	int unit = -1;
    981 	int pclk;
    982 
    983 	if (strcmp(kgdb_devname, "sscom0") == 0)
    984 		unit = 0;
    985 	else if (strcmp(kgdb_devname, "sscom1") == 0)
    986 		unit = 1;
    987 
    988 	if (unit >= 0) {
    989 		s3c24x0_clock_freq2(CLKMAN_VBASE, NULL, NULL, &pclk);
    990 
    991 		s3c2440_sscom_kgdb_attach(&s3c2xx0_bs_tag,
    992 		    unit, kgdb_rate, pclk, kgdb_sscom_mode);
    993 	}
    994 #endif
    995 }
    996 #endif
    997 
    998 
    999 static struct arm32_dma_range mini2440_dma_ranges[1];
   1000 
   1001 bus_dma_tag_t
   1002 s3c2xx0_bus_dma_init(struct arm32_bus_dma_tag *dma_tag_template)
   1003 {
   1004 	extern paddr_t physical_start, physical_end;
   1005 	struct arm32_bus_dma_tag *dmat;
   1006 
   1007 	mini2440_dma_ranges[0].dr_sysbase = physical_start;
   1008 	mini2440_dma_ranges[0].dr_busbase = physical_start;
   1009 	mini2440_dma_ranges[0].dr_len = physical_end - physical_start;
   1010 
   1011 #if 1
   1012 	dmat = dma_tag_template;
   1013 #else
   1014 	dmat = malloc(sizeof *dmat, M_DEVBUF, M_WAITOK);
   1015 	*dmat =  *dma_tag_template;
   1016 #endif
   1017 
   1018 	dmat->_ranges = mini2440_dma_ranges;
   1019 	dmat->_nranges = 1;
   1020 
   1021 	return dmat;
   1022 }
   1023 
   1024 void
   1025 mini2440_ksyms(struct btinfo_symtab *bi_symtab)
   1026 {
   1027 #if NKSYMS || defined(DDB) || defined(LKM)
   1028 	extern int end;
   1029 
   1030 #ifdef DDB
   1031 	db_machine_init();
   1032 #endif
   1033 	if (bi_symtab == NULL) {
   1034 		return;
   1035 	}
   1036 #ifdef VERBOSE_INIT_ARM
   1037 	printf("Got symbol table. nsym=%d, ssym=%p, esym=%p\n",
   1038 	       bi_symtab->nsym,
   1039 	       bi_symtab->ssym,
   1040 	       bi_symtab->esym);
   1041 #endif
   1042 
   1043 	ksyms_addsyms_elf(bi_symtab->nsym,
   1044 			  (int*)bi_symtab->ssym,
   1045 			  (int*)bi_symtab->esym);
   1046 #endif
   1047 }
   1048 
   1049 void *
   1050 lookup_bootinfo(int type)
   1051 {
   1052 	struct btinfo_common *bt;
   1053 	struct btinfo_common *help = (struct btinfo_common *)bootinfo;
   1054 
   1055 	if (help->next == 0)
   1056 		return (NULL);  /* bootinfo[] was not made */
   1057 	do {
   1058 		bt = help;
   1059 		if (bt->type == type)
   1060 			return (help);
   1061 		help = (struct btinfo_common *)((char*)help + bt->next);
   1062 	} while (bt->next &&
   1063 		 (size_t)help < (size_t)bootinfo + BOOTINFO_MAXSIZE);
   1064 
   1065 	return (NULL);
   1066 }
   1067 
   1068 
   1069 extern char *booted_kernel;
   1070 
   1071 static void
   1072 mini2440_device_register(device_t dev, void *aux) {
   1073 	if (device_class(dev) == DV_IFNET) {
   1074 #ifndef MEMORY_DISK_IS_ROOT
   1075 		if (bi_rdev != NULL && device_is_a(dev, bi_rdev->devname) ) {
   1076 			booted_device = dev;
   1077 			rootfstype = MOUNT_NFS;
   1078 			if( bi_path != NULL ) {
   1079 				booted_kernel = bi_path->bootpath;
   1080 			}
   1081 		}
   1082 #endif
   1083 		if (bi_net != NULL && device_is_a(dev, bi_net->devname)) {
   1084 			prop_data_t pd;
   1085 			pd = prop_data_create_data_nocopy(bi_net->mac_address, ETHER_ADDR_LEN);
   1086 			KASSERT(pd != NULL);
   1087 			if (prop_dictionary_set(device_properties(dev), "mac-address", pd) == false) {
   1088 				printf("WARNING: Unable to set mac-address property for %s\n", device_xname(dev));
   1089 			}
   1090 			prop_object_release(pd);
   1091 			bi_net = NULL;
   1092 		}
   1093 	}
   1094 #ifndef MEMORY_DISK_IS_ROOT
   1095 	if (bi_rdev != NULL && device_class(dev) == DV_DISK
   1096 	    && device_is_a(dev, bi_rdev->devname)
   1097 	    && device_unit(dev) == bi_rdev->cookie) {
   1098 		booted_device = dev;
   1099 		booted_partition = bi_rdev->partition;
   1100 		rootfstype = ROOT_FSTYPE_ANY;
   1101 		if( bi_path != NULL ) {
   1102 			booted_kernel = bi_path->bootpath;
   1103 		}
   1104 	}
   1105 #endif
   1106 }
   1107