/* 
 * Copyright 2010 Stefan Lankes, Chair for Operating Systems,
 *                               RWTH Aachen University
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * This file is part of MetalSVM.
 */

#include <metalsvm/stddef.h>
#include <metalsvm/stdio.h>
#include <metalsvm/string.h>
#include <metalsvm/errno.h>
#include <metalsvm/processor.h>
#include <asm/apic.h>
#include <asm/multiboot.h>

#define LAPIC_VERSION		0x0030
#define LAPIC_SVR		0x00F0

// 8259 controllers' I/O ports
#define MAST_8259_APORT		0x20
#define MAST_8259_DPORT		0x21
#define SLAV_8259_APORT		0xA0
#define SLAV_8259_DPORT		0xA1


static apic_mp_t* apic_mp = NULL;
static apic_config_table_t* apic_config = NULL;
static uint32_t ncores = 1;

int apic_init(void)
{
	size_t addr;
	uint32_t i, count;

	// searching MP signature in the reserved memory areas
#ifdef CONFIG_MULTIBOOT
	if (mb_info && (mb_info->flags & (1 << 6))) {
 		multiboot_memory_map_t* mmap = (multiboot_memory_map_t*) mb_info->mmap_addr;
		multiboot_memory_map_t* mmap_end = (void*) ((size_t) mb_info->mmap_addr + mb_info->mmap_length);

		while (mmap < mmap_end) {
			if (mmap->type == MULTIBOOT_MEMORY_RESERVED) {
				addr = mmap->addr;

				for(i=0; i<mmap->len; i++, addr++) {
					if (strncmp((void*)addr, "_MP_", 4) == 0) {
						apic_mp = (apic_mp_t*) addr;
						goto found_mp;
					}
				}
				
			}
			mmap++;
		}
	}
#endif
found_mp:

	if (!apic_mp) 
		goto out;

	kprintf("System uses Multiprocessing Specification 1.%d\n", apic_mp->version);	
	kprintf("MP features 1: %d\n", apic_mp->features[0]);

	if (apic_mp->features[0]) {
		kputs("Currently, MetalSVM supports only multiprocessing via the MP config tables!\n");
		goto out;
	}

	apic_config = (apic_config_table_t*) apic_mp->mp_config;
	if (!apic_config || strncmp((void*) &apic_config->signature, "PCMP", 4) !=0) {
		kputs("Invalid MP config table\n");
		goto out;
	}

	addr = (size_t) apic_config;
	addr += sizeof(apic_config_table_t);
	if (addr % 4)
		addr += 4 - addr % 4;

	for(i=0, count=0; i<apic_config->entry_count; i++) {
		if (*((uint8_t*) addr) == 0) {
			count++;
			addr += 20;
		} else addr += 8;
	}
	kprintf("Found %d cores\n", count);

	if (count > MAX_CORES) {
		kputs("Found too many cores! Increase the macro MAX_CORES!\n");
		goto out;
	}
	ncores = count;

	addr = apic_config->lapic;
	i = *((uint32_t*) (addr+LAPIC_VERSION));
	kprintf("Found LAPIC at 0x%x\n", addr);
	kprintf("Maximum LVT Entry: 0x%x\n", (i >> 16) & 0xFF);
	kprintf("LAPIC Version: 0x%x\n", i & 0xFF);
#if 0
	cpuid(0x1, &i);
	if (!(i & (1 << 5))) {
		kputs("Unable to use Machine-Specific Registers (MSR)\n");
		goto out;
	}

	if (!(rdmsr(0x1B) & (1 << 11))) {
		kputs("Unable to use APIC Global Enable flag!\n");
		goto out;
	}

	i = *((uint32_t*) (addr+LAPIC_SVR));
	kprintf("Supurious Interrupt Vector Register: %x\n", i);
	i = i | (1 << 8);
	*((uint32_t*) (addr+LAPIC_SVR)) = i;

	// Disable the 8259's because we are going to use the IOAPIC for interrupt processing
	outportb(MAST_8259_DPORT, 0xFF);	// OCW1 master: inhibit all interrupts
	udelay(100);
	outportb(SLAV_8259_DPORT, 0xFF);	// OCW1 slave: inhibit all interrupts

	return 0;
#endif
out:
	apic_mp = NULL;
	apic_config = NULL;
	ncores = 1;

	return -EINVAL;
}

int has_apic(void)
{
	return (apic_mp != NULL);
}