/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The 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, QUIET ENJOYMENT 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 */
uint64_t	max_mem;	/* Size of physical memory (bytes), adjusted by maxmem */

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++;
	}

	max_mem = mem_size;

	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();
}