[apple/xnu.git] / osfmk / ppc / ppc_vm_init.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * @OSF_COPYRIGHT@
 */
/*
 * @APPLE_FREE_COPYRIGHT@
 */

#include <mach_debug.h>
#include <mach_kdb.h>
#include <mach_kdp.h>
#include <debug.h>
#include <cpus.h>

#include <mach/vm_types.h>
#include <mach/vm_param.h>
#include <mach/thread_status.h>
#include <kern/misc_protos.h>
#include <kern/assert.h>
#include <kern/cpu_number.h>

#include <ppc/proc_reg.h>
#include <ppc/Firmware.h>
#include <ppc/boot.h>
#include <ppc/misc_protos.h>
#include <ppc/pmap.h>
#include <ppc/pmap_internals.h>
#include <ppc/mem.h>
#include <ppc/mappings.h>
#include <ppc/exception.h>
#include <ppc/mp.h>

#ifdef	__MACHO__
#include <mach-o/mach_header.h>
#endif

extern unsigned int intstack[];	/* declared in start.s */
extern unsigned int intstack_top_ss;	/* declared in start.s */

vm_offset_t mem_size;	/* Size of actual physical memory present
						   minus any performance buffer and possibly limited
						   by mem_limit in bytes */
vm_offset_t mem_actual;	/* The "One True" physical memory size 
						   actually, it's the highest physical address + 1 */
						  

mem_region_t pmap_mem_regions[PMAP_MEM_REGION_MAX];
int	 pmap_mem_regions_count = 0;	/* No non-contiguous memory regions */

mem_region_t free_regions[FREE_REGION_MAX];
int	     free_regions_count;

#ifndef __MACHO__  
extern unsigned long etext;
#endif

unsigned int avail_remaining = 0;
vm_offset_t first_avail;
vm_offset_t static_memory_end;
extern vm_offset_t avail_next;

#ifdef __MACHO__
extern struct mach_header _mh_execute_header;
vm_offset_t sectTEXTB;
int sectSizeTEXT;
vm_offset_t sectDATAB;
int sectSizeDATA;
vm_offset_t sectLINKB;
int sectSizeLINK;
vm_offset_t sectKLDB;
int sectSizeKLD;

vm_offset_t end, etext, edata;
#endif

extern unsigned long exception_entry;
extern unsigned long exception_end;


void ppc_vm_init(unsigned int mem_limit, boot_args *args)
{
	unsigned int htabmask;
	unsigned int i, j, batsize, kmapsize;
	vm_offset_t  addr;
	int boot_task_end_offset;
	const char *cpus;
	mapping		*mp;
	vm_offset_t first_phys_avail;
	vm_offset_t		sizeadj, oldstart;

	/* Now retrieve addresses for end, edata, and etext 
	 * from MACH-O headers.
	 */
	sectTEXTB = (vm_offset_t)getsegdatafromheader(
		&_mh_execute_header, "__TEXT", &sectSizeTEXT);
	sectDATAB = (vm_offset_t)getsegdatafromheader(
		&_mh_execute_header, "__DATA", &sectSizeDATA);
	sectLINKB = (vm_offset_t)getsegdatafromheader(
		&_mh_execute_header, "__LINKEDIT", &sectSizeLINK);
	sectKLDB = (vm_offset_t)getsegdatafromheader(
		&_mh_execute_header, "__KLD", &sectSizeKLD);

	etext = (vm_offset_t) sectTEXTB + sectSizeTEXT;
	edata = (vm_offset_t) sectDATAB + sectSizeDATA;
	end = round_page(getlastaddr());					/* Force end to next page */
#if DEBUG
	kprintf("sectTEXT: %x, size: %x\n", sectTEXTB, sectSizeTEXT);
	kprintf("sectDATA: %x, size: %x\n", sectDATAB, sectSizeDATA);
	kprintf("sectLINK: %x, size: %x\n", sectLINKB, sectSizeLINK);
	kprintf("sectKLD:  %x, size: %x\n", sectKLDB, sectSizeKLD);
	kprintf("end: %x\n", end);
#endif

/* Stitch valid memory regions together - they may be contiguous
 * even though they're not already glued together
 */
	mem_actual = args->PhysicalDRAM[0].base + args->PhysicalDRAM[0].size;	/* Initialize to the first region size */
	addr = 0;											/* temp use as pointer to previous memory region... */
	for (i = 1; i < kMaxDRAMBanks; i++) {
	  	
		if (args->PhysicalDRAM[i].size == 0) continue;	/* If region is empty, skip it */
		
	  	if((args->PhysicalDRAM[i].base + args->PhysicalDRAM[i].size) > mem_actual) {	/* New high? */
			mem_actual = args->PhysicalDRAM[i].base + args->PhysicalDRAM[i].size;	/* Take the high bid */
		}
		
		if (args->PhysicalDRAM[i].base ==				/* Does the end of the last hit the start of the next? */
		  args->PhysicalDRAM[addr].base +
		  args->PhysicalDRAM[addr].size) {
			kprintf("region 0x%08x size 0x%08x joining region 0x%08x size 0x%08x\n",
			  args->PhysicalDRAM[addr].base, args->PhysicalDRAM[addr].size,
			  args->PhysicalDRAM[i].base, args->PhysicalDRAM[i].size);
			
			args->PhysicalDRAM[addr].size += args->PhysicalDRAM[i].size;	/* Join them */
			args->PhysicalDRAM[i].size = 0;
			continue;
		}
		/* This is now last non-zero region to compare against */
		addr = i;
	}

	/* Go through the list of memory regions passed in via the args
	 * and copy valid entries into the pmap_mem_regions table, adding
	 * further calculated entries.
	 */
	
	pmap_mem_regions_count = 0;
	mem_size = 0;   /* Will use to total memory found so far */

	for (i = 0; i < kMaxDRAMBanks; i++) {
		if (args->PhysicalDRAM[i].size == 0)
			continue;

		/* The following should only happen if memory size has
		   been artificially reduced with -m */
		if (mem_limit > 0 &&
		    mem_size + args->PhysicalDRAM[i].size > mem_limit)
			args->PhysicalDRAM[i].size = mem_limit - mem_size;

		/* We've found a region, tally memory */

		pmap_mem_regions[pmap_mem_regions_count].start =
			args->PhysicalDRAM[i].base;
		pmap_mem_regions[pmap_mem_regions_count].end =
			args->PhysicalDRAM[i].base +
			args->PhysicalDRAM[i].size;

		/* Regions must be provided in ascending order */
		assert ((pmap_mem_regions_count == 0) ||
			pmap_mem_regions[pmap_mem_regions_count].start >
			pmap_mem_regions[pmap_mem_regions_count-1].start);

		if (pmap_mem_regions_count > 0) {		
			/* we add on any pages not in the first memory
			 * region to the avail_remaining count. The first
			 * memory region is used for mapping everything for
			 * bootup and is taken care of specially.
			 */
			avail_remaining +=
				args->PhysicalDRAM[i].size / PPC_PGBYTES;
		}
		
		/* Keep track of how much memory we've found */

		mem_size += args->PhysicalDRAM[i].size;

		/* incremement number of regions found */
		pmap_mem_regions_count++;
	}

	kprintf("mem_size: %d M\n",mem_size / (1024 * 1024));

	/* 
	 * Initialize the pmap system, using space above `first_avail'
	 * for the necessary data structures.
	 * NOTE : assume that we'll have enough space mapped in already
	 */

	first_phys_avail = static_memory_end;
	first_avail = adjust_bat_limit(first_phys_avail, 0, FALSE, FALSE);
	
	kmapsize = (round_page(exception_end) - trunc_page(exception_entry)) +	/* Get size we will map later */
		(round_page(sectTEXTB+sectSizeTEXT) - trunc_page(sectTEXTB)) +
		(round_page(sectDATAB+sectSizeDATA) - trunc_page(sectDATAB)) +
		(round_page(sectLINKB+sectSizeLINK) - trunc_page(sectLINKB)) +
		(round_page(sectKLDB+sectSizeKLD) - trunc_page(sectKLDB)) +
		(round_page(static_memory_end) - trunc_page(end));

	pmap_bootstrap(mem_size,&first_avail,&first_phys_avail, kmapsize);

#ifdef	__MACHO__
#if DEBUG
	kprintf("Mapping memory:\n");
	kprintf("   exception vector: %08X, %08X - %08X\n", trunc_page(exception_entry), 
		trunc_page(exception_entry), round_page(exception_end));
	kprintf("          sectTEXTB: %08X, %08X - %08X\n", trunc_page(sectTEXTB), 
		trunc_page(sectTEXTB), round_page(sectTEXTB+sectSizeTEXT));
	kprintf("          sectDATAB: %08X, %08X - %08X\n", trunc_page(sectDATAB), 
		trunc_page(sectDATAB), round_page(sectDATAB+sectSizeDATA));
	kprintf("          sectLINKB: %08X, %08X - %08X\n", trunc_page(sectLINKB), 
		trunc_page(sectLINKB), round_page(sectLINKB+sectSizeLINK));
	kprintf("           sectKLDB: %08X, %08X - %08X\n", trunc_page(sectKLDB), 
		trunc_page(sectKLDB), round_page(sectKLDB+sectSizeKLD));
	kprintf("                end: %08X, %08X - %08X\n", trunc_page(end), 
		trunc_page(end), static_memory_end);
#endif /* DEBUG */
	pmap_map(trunc_page(exception_entry), trunc_page(exception_entry), 
		round_page(exception_end), VM_PROT_READ|VM_PROT_EXECUTE);
	pmap_map(trunc_page(sectTEXTB), trunc_page(sectTEXTB), 
		round_page(sectTEXTB+sectSizeTEXT), VM_PROT_READ|VM_PROT_EXECUTE);
	pmap_map(trunc_page(sectDATAB), trunc_page(sectDATAB), 
		round_page(sectDATAB+sectSizeDATA), VM_PROT_READ|VM_PROT_WRITE);


       /* The KLD and LINKEDIT segments are unloaded in toto after boot completes,
        * but via ml_static_mfree(), through IODTFreeLoaderInfo(). Hence, we have
        * to map both segments page-by-page.
        */
	for (addr = trunc_page(sectKLDB);
             addr < round_page(sectKLDB+sectSizeKLD);
             addr += PAGE_SIZE) {

            pmap_enter(kernel_pmap, addr, addr, 
			VM_PROT_READ|VM_PROT_WRITE, 
			VM_WIMG_USE_DEFAULT, TRUE);
	}

	for (addr = trunc_page(sectLINKB);
             addr < round_page(sectLINKB+sectSizeLINK);
             addr += PAGE_SIZE) {

            pmap_enter(kernel_pmap, addr, addr, 
			VM_PROT_READ|VM_PROT_WRITE, 
			VM_WIMG_USE_DEFAULT, TRUE);
	}

/*
 *	We need to map the remainder page-by-page because some of this will
 *	be released later, but not all.  Ergo, no block mapping here 
 */
	for(addr = trunc_page(end); addr < round_page(static_memory_end); addr += PAGE_SIZE) {
		pmap_enter(kernel_pmap, addr, addr, 
			VM_PROT_READ|VM_PROT_WRITE, 
			VM_WIMG_USE_DEFAULT, TRUE);
	}
#endif /* __MACHO__ */

#if DEBUG
	for (i=0 ; i < free_regions_count; i++) {
		kprintf("Free region start 0x%08x end 0x%08x\n",
		       free_regions[i].start,free_regions[i].end);
	}
#endif

/*
 *	Note: the shadow BAT registers were already loaded in ppc_init.c
 */


	LoadIBATs((unsigned int *)&shadow_BAT.IBATs[0]);		/* Load up real IBATs from shadows */
	LoadDBATs((unsigned int *)&shadow_BAT.DBATs[0]);		/* Load up real DBATs from shadows */

#if DEBUG
	for(i=0; i<4; i++) kprintf("DBAT%1d: %08X %08X\n", 
		i, shadow_BAT.DBATs[i].upper, shadow_BAT.DBATs[i].lower);
	for(i=0; i<4; i++) kprintf("IBAT%1d: %08X %08X\n", 
		i, shadow_BAT.IBATs[i].upper, shadow_BAT.IBATs[i].lower);
#endif
}

void ppc_vm_cpu_init(
	struct per_proc_info *proc_info)
{
	hash_table_init(hash_table_base, hash_table_size);

	LoadIBATs((unsigned int *)&shadow_BAT.IBATs[0]);
	LoadDBATs((unsigned int *)&shadow_BAT.DBATs[0]);

	sync();isync();
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* @OSF_COPYRIGHT@
	24	*/
	25	/*
	26	* @APPLE_FREE_COPYRIGHT@
	27	*/
	28
	29	#include <mach_debug.h>
	30	#include <mach_kdb.h>
	31	#include <mach_kdp.h>
	32	#include <debug.h>
	33	#include <cpus.h>
	34
	35	#include <mach/vm_types.h>
	36	#include <mach/vm_param.h>
	37	#include <mach/thread_status.h>
	38	#include <kern/misc_protos.h>
	39	#include <kern/assert.h>
	40	#include <kern/cpu_number.h>
	41
	42	#include <ppc/proc_reg.h>
	43	#include <ppc/Firmware.h>
	44	#include <ppc/boot.h>
	45	#include <ppc/misc_protos.h>
	46	#include <ppc/pmap.h>
	47	#include <ppc/pmap_internals.h>
	48	#include <ppc/mem.h>
	49	#include <ppc/mappings.h>
	50	#include <ppc/exception.h>
	51	#include <ppc/mp.h>
	52
	53	#ifdef __MACHO__
	54	#include <mach-o/mach_header.h>
	55	#endif
	56
	57	extern unsigned int intstack[]; /* declared in start.s */
	58	extern unsigned int intstack_top_ss; /* declared in start.s */
	59
	60	vm_offset_t mem_size; /* Size of actual physical memory present
	61	minus any performance buffer and possibly limited
	62	by mem_limit in bytes */
	63	vm_offset_t mem_actual; /* The "One True" physical memory size
	64	actually, it's the highest physical address + 1 */
65
66
67	mem_region_t pmap_mem_regions[PMAP_MEM_REGION_MAX];
68	int pmap_mem_regions_count = 0; /* No non-contiguous memory regions */
69
70	mem_region_t free_regions[FREE_REGION_MAX];
71	int free_regions_count;
72
73	#ifndef __MACHO__
74	extern unsigned long etext;
75	#endif
76
77	unsigned int avail_remaining = 0;
78	vm_offset_t first_avail;
79	vm_offset_t static_memory_end;
80	extern vm_offset_t avail_next;
81
82	#ifdef __MACHO__
83	extern struct mach_header _mh_execute_header;
84	vm_offset_t sectTEXTB;
85	int sectSizeTEXT;
86	vm_offset_t sectDATAB;
87	int sectSizeDATA;
1c79356b A	88	vm_offset_t sectLINKB;
	89	int sectSizeLINK;
	90	vm_offset_t sectKLDB;
	91	int sectSizeKLD;
	92
	93	vm_offset_t end, etext, edata;
	94	#endif
	95
	96	extern unsigned long exception_entry;
	97	extern unsigned long exception_end;
	98
	99
	100	void ppc_vm_init(unsigned int mem_limit, boot_args *args)
	101	{
	102	unsigned int htabmask;
	103	unsigned int i, j, batsize, kmapsize;
	104	vm_offset_t addr;
	105	int boot_task_end_offset;
	106	const char *cpus;
	107	mapping *mp;
	108	vm_offset_t first_phys_avail;
	109	vm_offset_t sizeadj, oldstart;
	110
1c79356b A	111	/* Now retrieve addresses for end, edata, and etext
	112	* from MACH-O headers.
	113	*/
	114	sectTEXTB = (vm_offset_t)getsegdatafromheader(
	115	&_mh_execute_header, "__TEXT", &sectSizeTEXT);
	116	sectDATAB = (vm_offset_t)getsegdatafromheader(
	117	&_mh_execute_header, "__DATA", &sectSizeDATA);
1c79356b A	118	sectLINKB = (vm_offset_t)getsegdatafromheader(
	119	&_mh_execute_header, "__LINKEDIT", &sectSizeLINK);
	120	sectKLDB = (vm_offset_t)getsegdatafromheader(
	121	&_mh_execute_header, "__KLD", &sectSizeKLD);
	122
	123	etext = (vm_offset_t) sectTEXTB + sectSizeTEXT;
	124	edata = (vm_offset_t) sectDATAB + sectSizeDATA;
	125	end = round_page(getlastaddr()); /* Force end to next page */
	126	#if DEBUG
	127	kprintf("sectTEXT: %x, size: %x\n", sectTEXTB, sectSizeTEXT);
	128	kprintf("sectDATA: %x, size: %x\n", sectDATAB, sectSizeDATA);
1c79356b A	129	kprintf("sectLINK: %x, size: %x\n", sectLINKB, sectSizeLINK);
	130	kprintf("sectKLD: %x, size: %x\n", sectKLDB, sectSizeKLD);
	131	kprintf("end: %x\n", end);
	132	#endif
1c79356b A	133
	134	/* Stitch valid memory regions together - they may be contiguous
	135	* even though they're not already glued together
	136	*/
0b4e3aa0	137	mem_actual = args->PhysicalDRAM[0].base + args->PhysicalDRAM[0].size; /* Initialize to the first region size */
1c79356b A	138	addr = 0; /* temp use as pointer to previous memory region... */
	139	for (i = 1; i < kMaxDRAMBanks; i++) {
	140
	141	if (args->PhysicalDRAM[i].size == 0) continue; /* If region is empty, skip it */
	142
	143	if((args->PhysicalDRAM[i].base + args->PhysicalDRAM[i].size) > mem_actual) { /* New high? */
	144	mem_actual = args->PhysicalDRAM[i].base + args->PhysicalDRAM[i].size; /* Take the high bid */
	145	}
	146
	147	if (args->PhysicalDRAM[i].base == /* Does the end of the last hit the start of the next? */
	148	args->PhysicalDRAM[addr].base +
	149	args->PhysicalDRAM[addr].size) {
	150	kprintf("region 0x%08x size 0x%08x joining region 0x%08x size 0x%08x\n",
	151	args->PhysicalDRAM[addr].base, args->PhysicalDRAM[addr].size,
	152	args->PhysicalDRAM[i].base, args->PhysicalDRAM[i].size);
	153
	154	args->PhysicalDRAM[addr].size += args->PhysicalDRAM[i].size; /* Join them */
	155	args->PhysicalDRAM[i].size = 0;
	156	continue;
	157	}
	158	/* This is now last non-zero region to compare against */
	159	addr = i;
	160	}
	161
	162	/* Go through the list of memory regions passed in via the args
	163	* and copy valid entries into the pmap_mem_regions table, adding
	164	* further calculated entries.
	165	*/
	166
	167	pmap_mem_regions_count = 0;
	168	mem_size = 0; /* Will use to total memory found so far */
	169
	170	for (i = 0; i < kMaxDRAMBanks; i++) {
	171	if (args->PhysicalDRAM[i].size == 0)
	172	continue;
	173
	174	/* The following should only happen if memory size has
	175	been artificially reduced with -m */
	176	if (mem_limit > 0 &&
	177	mem_size + args->PhysicalDRAM[i].size > mem_limit)
	178	args->PhysicalDRAM[i].size = mem_limit - mem_size;
	179
	180	/* We've found a region, tally memory */
	181
	182	pmap_mem_regions[pmap_mem_regions_count].start =
	183	args->PhysicalDRAM[i].base;
	184	pmap_mem_regions[pmap_mem_regions_count].end =
	185	args->PhysicalDRAM[i].base +
	186	args->PhysicalDRAM[i].size;
	187
	188	/* Regions must be provided in ascending order */
	189	assert ((pmap_mem_regions_count == 0) \|\|
	190	pmap_mem_regions[pmap_mem_regions_count].start >
	191	pmap_mem_regions[pmap_mem_regions_count-1].start);
	192
	193	if (pmap_mem_regions_count > 0) {
	194	/* we add on any pages not in the first memory
	195	* region to the avail_remaining count. The first
	196	* memory region is used for mapping everything for
	197	* bootup and is taken care of specially.
	198	*/
	199	avail_remaining +=
	200	args->PhysicalDRAM[i].size / PPC_PGBYTES;
	201	}
202
203	/* Keep track of how much memory we've found */
204
205	mem_size += args->PhysicalDRAM[i].size;
206
207	/* incremement number of regions found */
208	pmap_mem_regions_count++;
209	}
210
211	kprintf("mem_size: %d M\n",mem_size / (1024 * 1024));
212
213	/*
214	* Initialize the pmap system, using space above `first_avail'
215	* for the necessary data structures.
216	* NOTE : assume that we'll have enough space mapped in already
217	*/
218
219	first_phys_avail = static_memory_end;
220	first_avail = adjust_bat_limit(first_phys_avail, 0, FALSE, FALSE);
221
222	kmapsize = (round_page(exception_end) - trunc_page(exception_entry)) + /* Get size we will map later */
223	(round_page(sectTEXTB+sectSizeTEXT) - trunc_page(sectTEXTB)) +
224	(round_page(sectDATAB+sectSizeDATA) - trunc_page(sectDATAB)) +
1c79356b A	225	(round_page(sectLINKB+sectSizeLINK) - trunc_page(sectLINKB)) +
	226	(round_page(sectKLDB+sectSizeKLD) - trunc_page(sectKLDB)) +
	227	(round_page(static_memory_end) - trunc_page(end));
	228
	229	pmap_bootstrap(mem_size,&first_avail,&first_phys_avail, kmapsize);
	230
	231	#ifdef __MACHO__
	232	#if DEBUG
	233	kprintf("Mapping memory:\n");
	234	kprintf(" exception vector: %08X, %08X - %08X\n", trunc_page(exception_entry),
	235	trunc_page(exception_entry), round_page(exception_end));
	236	kprintf(" sectTEXTB: %08X, %08X - %08X\n", trunc_page(sectTEXTB),
	237	trunc_page(sectTEXTB), round_page(sectTEXTB+sectSizeTEXT));
	238	kprintf(" sectDATAB: %08X, %08X - %08X\n", trunc_page(sectDATAB),
	239	trunc_page(sectDATAB), round_page(sectDATAB+sectSizeDATA));
1c79356b A	240	kprintf(" sectLINKB: %08X, %08X - %08X\n", trunc_page(sectLINKB),
	241	trunc_page(sectLINKB), round_page(sectLINKB+sectSizeLINK));
	242	kprintf(" sectKLDB: %08X, %08X - %08X\n", trunc_page(sectKLDB),
	243	trunc_page(sectKLDB), round_page(sectKLDB+sectSizeKLD));
	244	kprintf(" end: %08X, %08X - %08X\n", trunc_page(end),
	245	trunc_page(end), static_memory_end);
	246	#endif /* DEBUG */
	247	pmap_map(trunc_page(exception_entry), trunc_page(exception_entry),
	248	round_page(exception_end), VM_PROT_READ\|VM_PROT_EXECUTE);
	249	pmap_map(trunc_page(sectTEXTB), trunc_page(sectTEXTB),
	250	round_page(sectTEXTB+sectSizeTEXT), VM_PROT_READ\|VM_PROT_EXECUTE);
	251	pmap_map(trunc_page(sectDATAB), trunc_page(sectDATAB),
	252	round_page(sectDATAB+sectSizeDATA), VM_PROT_READ\|VM_PROT_WRITE);
1c79356b A	253
	254
	255	/* The KLD and LINKEDIT segments are unloaded in toto after boot completes,
	256	* but via ml_static_mfree(), through IODTFreeLoaderInfo(). Hence, we have
	257	* to map both segments page-by-page.
	258	*/
	259	for (addr = trunc_page(sectKLDB);
	260	addr < round_page(sectKLDB+sectSizeKLD);
	261	addr += PAGE_SIZE) {
	262
9bccf70c A	263	pmap_enter(kernel_pmap, addr, addr,
	264	VM_PROT_READ\|VM_PROT_WRITE,
	265	VM_WIMG_USE_DEFAULT, TRUE);
1c79356b A	266	}
	267
	268	for (addr = trunc_page(sectLINKB);
	269	addr < round_page(sectLINKB+sectSizeLINK);
	270	addr += PAGE_SIZE) {
	271
9bccf70c A	272	pmap_enter(kernel_pmap, addr, addr,
	273	VM_PROT_READ\|VM_PROT_WRITE,
	274	VM_WIMG_USE_DEFAULT, TRUE);
1c79356b A	275	}
	276
	277	/*
	278	* We need to map the remainder page-by-page because some of this will
	279	* be released later, but not all. Ergo, no block mapping here
	280	*/
	281	for(addr = trunc_page(end); addr < round_page(static_memory_end); addr += PAGE_SIZE) {
9bccf70c A	282	pmap_enter(kernel_pmap, addr, addr,
	283	VM_PROT_READ\|VM_PROT_WRITE,
	284	VM_WIMG_USE_DEFAULT, TRUE);
1c79356b A	285	}
	286	#endif /* __MACHO__ */
	287
	288	#if DEBUG
	289	for (i=0 ; i < free_regions_count; i++) {
	290	kprintf("Free region start 0x%08x end 0x%08x\n",
	291	free_regions[i].start,free_regions[i].end);
	292	}
	293	#endif
	294
d52fe63f A	295	/*
	296	* Note: the shadow BAT registers were already loaded in ppc_init.c
	297	*/
1c79356b	298
1c79356b	299
d52fe63f	300	LoadIBATs((unsigned int )&shadow_BAT.IBATs[0]); / Load up real IBATs from shadows */
1c79356b A	301	LoadDBATs((unsigned int )&shadow_BAT.DBATs[0]); / Load up real DBATs from shadows */
1c79356b A	302
1c79356b A	303	#if DEBUG
	304	for(i=0; i<4; i++) kprintf("DBAT%1d: %08X %08X\n",
	305	i, shadow_BAT.DBATs[i].upper, shadow_BAT.DBATs[i].lower);
	306	for(i=0; i<4; i++) kprintf("IBAT%1d: %08X %08X\n",
	307	i, shadow_BAT.IBATs[i].upper, shadow_BAT.IBATs[i].lower);
	308	#endif
	309	}
	310
	311	void ppc_vm_cpu_init(
	312	struct per_proc_info *proc_info)
	313	{
	314	hash_table_init(hash_table_base, hash_table_size);
	315
	316	LoadIBATs((unsigned int *)&shadow_BAT.IBATs[0]);
	317	LoadDBATs((unsigned int *)&shadow_BAT.DBATs[0]);
	318
	319	sync();isync();
	320	}