/* This file is part of the UCB release of Plan 9. It is subject to the license
 * terms in the LICENSE file found in the top-level directory of this
 * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
 * part of the UCB release of Plan 9, including this file, may be copied,
 * modified, propagated, or distributed except according to the terms contained
 * in the LICENSE file. */

#include <slab.h>
#include <kmalloc.h>
#include <kref.h>
#include <string.h>
#include <stdio.h>
#include <assert.h>
#include <error.h>
#include <cpio.h>
#include <pmap.h>
#include <smp.h>
#include <net/ip.h>
#include <acpi.h>
#include <arch/ioapic.h>
#include <arch/topology.h>

int mpacpi(int ncleft)
{
	char *already;
	int np, bp;
	struct apic *apic;
	struct Apicst *st;
	struct Madt *mt;

	/* If we don't have an mpisabusno yet, it's because the MP tables failed to
	 * parse.  So we'll just take the last one available.  I think we're
	 * supposed to parse the ACPI shit with the AML to figure out the buses and
	 * find a clear one, but fuck that.  Note this busno is just for our own
	 * RDT/Rbus bookkeeping. */
	if (mpisabusno == -1)
		mpisabusno = Nbus - 1;

	if (apics == NULL)
		return ncleft;
	mt = apics->tbl;
	if (mt == NULL)
		return ncleft;

	printd("APIC lapic paddr %#.8llux, flags %#.8ux\n",
		   mt->lapicpa, mt->pcat);
	np = 0;
	printd("apics->st %p\n", apics->st);
	for (int i = 0; i < apics->nchildren; i++) {
		st = apics->children[i]->tbl;
		already = "";
		switch (st->type) {
			case ASlapic:
				printd("ASlapic %d\n", st->lapic.id);
				/* this table is supposed to have all of them if it exists */
				if (st->lapic.id > MaxAPICNO)
					break;
				apic = xlapic + st->lapic.id;
				bp = (np++ == 0);
				if (apic->useable) {
					already = "(mp)";
				} else if (ncleft != 0) {
					ncleft--;
					apicinit(st->lapic.id, mt->lapicpa, bp);
				} else
					already = "(off)";

				printd("apic proc %d/%d apicid %d %s\n", np - 1, apic->machno,
					   st->lapic.id, already);
				break;
			case ASioapic:
				printd("ASioapic %d\n", st->ioapic.id);
				if (st->ioapic.id > Napic)
					break;
				apic = xioapic + st->ioapic.id;
				if (apic->useable) {
					apic->ibase = st->ioapic.ibase;	/* gnarly */
					already = "(mp)";
					goto pr1;
				}
				ioapicinit(st->ioapic.id, st->ioapic.ibase, st->ioapic.addr);
pr1:
				printd("ioapic %d ", st->ioapic.id);
				printd("addr %p base %d %s\n", apic->paddr, apic->ibase,
					   already);
				break;
		}
	}
	return ncleft;
}
