path: root/system/alpha/console/console.c

/*
 * Copyright (c) 2003, 2004
 * The Regents of The University of Michigan
 * All Rights Reserved
 *
 * This code is part of the M5 simulator, developed by Nathan Binkert,
 * Erik Hallnor, Steve Raasch, and Steve Reinhardt, with contributions
 * from Ron Dreslinski, Dave Greene, Lisa Hsu, Ali Saidi, and Andrew
 * Schultz.
 *
 * Permission is granted to use, copy, create derivative works and
 * redistribute this software and such derivative works for any purpose,
 * so long as the copyright notice above, this grant of permission, and
 * the disclaimer below appear in all copies made; and so long as the
 * name of The University of Michigan is not used in any advertising or
 * publicity pertaining to the use or distribution of this software
 * without specific, written prior authorization.
 *
 * THIS SOFTWARE IS PROVIDED AS IS, WITHOUT REPRESENTATION FROM THE
 * UNIVERSITY OF MICHIGAN AS TO ITS FITNESS FOR ANY PURPOSE, AND WITHOUT
 * WARRANTY BY THE UNIVERSITY OF MICHIGAN OF ANY KIND, EITHER EXPRESS OR
 * IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE REGENTS OF
 * THE UNIVERSITY OF MICHIGAN SHALL NOT BE LIABLE FOR ANY DAMAGES,
 * INCLUDING DIRECT, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
 * DAMAGES, WITH RESPECT TO ANY CLAIM ARISING OUT OF OR IN CONNECTION
 * WITH THE USE OF THE SOFTWARE, EVEN IF IT HAS BEEN OR IS HEREAFTER
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 */

/*
 * Copyright 1993 Hewlett-Packard Development Company, L.P.
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy,
 * modify, merge, publish, distribute, sublicense, and/or sell copies
 * of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/* ******************************************
 * M5 Console
 * ******************************************/

#include <linux/stddef.h>
#include <sys/types.h>

#define CONSOLE
#include "alpha_access.h"
#include "cserve.h"
#include "rpb.h"

#define CONS_INT_TX   0x01  /* interrupt enable / state bits */
#define CONS_INT_RX   0x02

#define PAGE_SIZE (8192)

#define KSTACK_REGION_VA 0x20040000

#define KSEG   0xfffffc0000000000
#define K1BASE 0xfffffc8000000000
#define KSEG_TO_PHYS(x) (((ulong)x) & ~KSEG)

#define ROUNDUP8(x) ((ulong)(((ulong)x)+7) & ~7)
#define ROUNDUP128(x) ((ulong)(((ulong)x) + 127) & ~127)
#define ROUNDUP8K(x) ((ulong)(((ulong)(x)) + 8191) & ~8191)

#define FIRST(x)  ((((ulong)(x)) >> 33) & 0x3ff)
#define SECOND(x) ((((ulong)(x)) >> 23) & 0x3ff)
#define THIRD(x) ((((ulong)(x)) >> 13) & 0x3ff)
#define THIRD_XXX(x)  ((((ulong)(x)) >> 13) & 0xfff)
#define PFN(x)  ((((ulong)(x) & ~KSEG) >> 13))

/* Kernel write | kernel read | valid */
#define KPTE(x) ((ulong)((((ulong)(x)) << 32) | 0x1101))

#define HWRPB_PAGES 16
#define MDT_BITMAP_PAGES  4

#define NUM_KERNEL_THIRD (4)

#define printf_lock(args...)		\
    do {				\
        SpinLock(&theLock);		\
        printf(args);			\
        SpinUnlock(&theLock);		\
    } while (0)


void unixBoot(int argc, char **argv);
void JToKern(char *bootadr, ulong rpb_percpu, ulong free_pfn, ulong k_argc,
             char **k_argv, char **envp);
void JToPal(ulong bootadr);
void SlaveLoop(int cpu);

volatile struct AlphaAccess *m5AlphaAccess;
struct AlphaAccess m5Conf;

ulong theLock;

extern void SpinLock(ulong *lock);
#define SpinUnlock(_x) *(_x) = 0;

struct _kernel_params {
    char *bootadr;
    ulong rpb_percpu;
    ulong free_pfn;
    ulong argc;
    ulong argv;
    ulong envp; /* NULL */
};

extern consoleCallback[];
extern consoleFixup[];
long CallBackDispatcher();
long CallBackFixup();

/*
 * m5 console output
 */

void
InitConsole()
{
}

char
GetChar()
{
    return m5AlphaAccess->inputChar;
}

void
PutChar(char c)
{
    m5AlphaAccess->outputChar = c;
}

int
passArgs(int argc)
{
    return 0;
}

int
main(int argc, char **argv)
{
    int x, i;
    uint *k1ptr, *ksegptr;

    InitConsole();
    printf_lock("M5 console: m5AlphaAccess @ 0x%x\n", m5AlphaAccess);

    /*
     * get configuration from backdoor
     */
    m5Conf.last_offset = m5AlphaAccess->last_offset;
    printf_lock("Got Configuration %d\n", m5Conf.last_offset);

    m5Conf.last_offset = m5AlphaAccess->last_offset;
    m5Conf.version = m5AlphaAccess->version;
    m5Conf.numCPUs = m5AlphaAccess->numCPUs;
    m5Conf.intrClockFrequency = m5AlphaAccess->intrClockFrequency;
    m5Conf.cpuClock = m5AlphaAccess->cpuClock;
    m5Conf.mem_size = m5AlphaAccess->mem_size;
    m5Conf.kernStart = m5AlphaAccess->kernStart;
    m5Conf.kernEnd = m5AlphaAccess->kernEnd;
    m5Conf.entryPoint = m5AlphaAccess->entryPoint;
    m5Conf.diskUnit = m5AlphaAccess->diskUnit;
    m5Conf.diskCount = m5AlphaAccess->diskCount;
    m5Conf.diskPAddr = m5AlphaAccess->diskPAddr;
    m5Conf.diskBlock = m5AlphaAccess->diskBlock;
    m5Conf.diskOperation = m5AlphaAccess->diskOperation;
    m5Conf.outputChar = m5AlphaAccess->outputChar;
    m5Conf.inputChar = m5AlphaAccess->inputChar;
    m5Conf.bootStrapImpure = m5AlphaAccess->bootStrapImpure;
    m5Conf.bootStrapCPU = m5AlphaAccess->bootStrapCPU;

    if (m5Conf.version != ALPHA_ACCESS_VERSION)  {
        panic("Console version mismatch. Console expects %d. has %d \n",
              ALPHA_ACCESS_VERSION, m5Conf.version);
    }

    /*
     * setup arguments to kernel
     */
    unixBoot(argc, argv);

    panic("unix failed to boot\n");
    return 1;
}

/*
 * BOOTING
 */
struct rpb m5_rpb = {
    NULL,		/* 000: physical self-reference */
    ((long)'H') | (((long)'W') << 8) | (((long)'R') << 16) |
    ((long)'P' << 24) | (((long)'B') << 32),  /* 008: contains "HWRPB" */
    6,			/* 010: HWRPB version number */
    /* the byte count is wrong, but who needs it? - lance */
    0,			/* 018: bytes in RPB perCPU CTB CRB MEDSC */
    0,			/* 020: primary cpu id */
    PAGE_SIZE,		/* 028: page size in bytes */
    43,			/* 030: number of phys addr bits */
    127,		/* 038: max valid ASN */
    {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','1'},
                        /* 040: system serial num: 10 ascii chars */
    0, /* OVERRIDDEN */
    (1<<10),		/* 058: system variation */
    'c'|('o'<<8)|('o'<<16)|('l'<< 24),	/* 060: system revision */
    1024*4096,		/* 068: scaled interval clock intr freq */
    0,			/* 070: cycle counter frequency */
    0x200000000,	/* 078: virtual page table base */
    0,			/* 080: reserved */
    0,			/* 088: offset to translation buffer hint */
    1,			/* 090: number of processor slots OVERRIDDEN*/
    sizeof(struct rpb_percpu),	/* 098: per-cpu slot size. OVERRIDDEN */
    0,			/* 0A0: offset to per_cpu slots */
    1,			/* 0A8: number of CTBs */
    sizeof(struct ctb_tt),
    0,			/* 0B8: offset to CTB (cons term block) */
    0,			/* 0C0: offset to CRB (cons routine block) */
    0,			/* 0C8: offset to memory descriptor table */
    0,			/* 0D0: offset to config data block */
    0,			/* 0D8: offset to FRU table */
    0,			/* 0E0: virt addr of save term routine */
    0,			/* 0E8: proc value for save term routine */
    0,			/* 0F0: virt addr of restore term routine */
    0,			/* 0F8: proc value for restore term routine */
    0,			/* 100: virt addr of CPU restart routine */
    0,			/* 108: proc value for CPU restart routine */
    0,			/* 110: used to determine presence of kdebug */
    0,			/* 118: reserved for hardware */
/* the checksum is wrong, but who needs it? - lance */
    0,			/* 120: checksum of prior entries in rpb */
    0,			/* 128: receive ready bitmask */
    0,			/* 130: transmit ready bitmask */
    0,			/* 138: Dynamic System Recog. offset */
};

ulong m5_tbb[] = { 0x1e1e1e1e1e1e1e1e, 0x1e1e1e1e1e1e1e1e,
                   0x1e1e1e1e1e1e1e1e, 0x1e1e1e1e1e1e1e1e,
                   0x1e1e1e1e1e1e1e1e, 0x1e1e1e1e1e1e1e1e,
                   0x1e1e1e1e1e1e1e1e, 0x1e1e1e1e1e1e1e1e };

struct rpb_percpu m5_rpb_percpu = {
    {0,0,0,0,0,0,1,{0,0},{0,0,0,0,0,0,0,0}}, /* 000: boot/restart HWPCB */
    (STATE_PA | STATE_PP | STATE_CV |
     STATE_PV | STATE_PMV | STATE_PL), 	/* 080: per-cpu state bits */
    0xc000,				/* 088: palcode memory length */
    0x2000,				/* 090: palcode scratch length */
    0x4000,				/* 098: paddr of pal mem space */
    0x2000,				/* 0A0: paddr of pal scratch space */
    (2 << 16) | (5 << 8) | 1,		/* 0A8: PALcode rev required */
    11 | (2L  << 32),			/* 0B0: processor type */
    7,					/* 0B8: processor variation */
    'M'|('5'<<8)|('A'<<16)|('0'<<24),	/* 0C0: processor revision */
    {'M','5','/','A','l','p','h','a','0','0','0','0','0','0','0','0'},
                                        /* 0C8: proc serial num: 10 chars */
    0,					/* 0D8: phys addr of logout area */
    0,					/* 0E0: len in bytes of logout area */
    0,					/* 0E8: halt pcb base */
    0,					/* 0F0: halt pc */
    0,					/* 0F8: halt ps */
    0,					/* 100: halt arg list (R25) */
    0,					/* 108: halt return address (R26) */
    0,					/* 110: halt procedure value (R27) */
    0,		       			/* 118: reason for halt */
    0,		       			/* 120: for software */
    {0},				/* 128: inter-console comm buffer */
    {1,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0},	/* 1D0: PALcode revs available */
    0					/* 250: reserved for arch use */
/* the dump stack grows from the end of the rpb page not to reach here */
};

struct _m5_rpb_mdt {
    long   rpb_checksum;	/* 000: checksum of entire mem desc table */
    long   rpb_impaddr;		/* 008: PA of implementation dep info */
    long   rpb_numcl;		/* 010: number of clusters */
    struct rpb_cluster rpb_cluster[3];	/* first instance of a cluster */
};

struct _m5_rpb_mdt m5_rpb_mdt = {
    0,			/* 000: checksum of entire mem desc table */
    0,			/* 008: PA of implementation dep info */
    0,			/* 010: number of clusters */
    {{	0,		/* 000: starting PFN of this cluster */
        0,		/* 008: count of PFNs in this cluster */
        0,		/* 010: count of tested PFNs in cluster */
        0,		/* 018: va of bitmap */
        0,		/* 020: pa of bitmap */
        0,		/* 028: checksum of bitmap */
        1		/* 030: usage of cluster */
     },
     {   0,		/* 000: starting PFN of this cluster */
         0,		/* 008: count of PFNs in this cluster */
         0,		/* 010: count of tested PFNs in cluster */
         0,		/* 018: va of bitmap */
         0,		/* 020: pa of bitmap */
         0,		/* 028: checksum of bitmap */
         0		/* 030: usage of cluster */
     },
     {   0,		/* 000: starting PFN of this cluster */
         0,		/* 008: count of PFNs in this cluster */
         0,		/* 010: count of tested PFNs in cluster */
         0,		/* 018: va of bitmap */
         0,		/* 020: pa of bitmap */
         0,		/* 028: checksum of bitmap */
         0		/* 030: usage of cluster */
     }}
};

/* constants for slotinfo bus_type subfield */
#define SLOTINFO_TC	0
#define SLOTINFO_ISA	1
#define SLOTINFO_EISA	2
#define SLOTINFO_PCI	3

struct rpb_ctb m5_rpb_ctb = {
    CONS_DZ,	/* 000: console type */
    0,		/* 008: console unit */
    0,		/* 010: reserved */
    0		/* 018: byte length of device dep portion */
};

/* we don't do any fixup (aka relocate the console) - we hope */
struct rpb_crb m5_rpb_crb = {
    0,		/* va of call-back dispatch rtn */
    0,		/* pa of call-back dispatch rtn */
    0,		/* va of call-back fixup rtn */
    0,		/* pa of call-back fixup rtn */
    0,		/* number of entries in phys/virt map */
    0		/* Number of pages to be mapped */
};

struct _rpb_name {
    ulong length;
    char name[16];
};

extern struct _rpb_name m5_name;

struct rpb_dsr m5_rpb_dsr = {
    0,
    0,
    0,
};

struct _rpb_name m5_name = {
    16,
    {'U','M','I','C','H',' ','M','5','/','A','L','P','H','A',' ',0},
};

/*
 * M5 has one LURT entry:
 *   1050 is for workstations
 *   1100 is servers (and is needed for CXX)
 */
long m5_lurt[10] = { 9, 12, -1, -1, -1, -1, -1, -1, 1100, 1100 };

ulong unix_boot_mem;
ulong bootadr;

char **kargv;
int kargc;
ulong free_pfn;
struct rpb_percpu *rpb_percpu;

char *
unix_boot_alloc(int pages)
{
    char *ret = (char *)unix_boot_mem;
    unix_boot_mem += (pages * PAGE_SIZE);
    return ret;
}

ulong *first = 0;
ulong *third_rpb = 0;
ulong *reservedFixup = 0;

int strcpy(char *dst, char *src);

struct rpb *rpb;
extern ulong _end;

void
unixBoot(int argc, char **argv)
{
    ulong *second,  *third_kernel, ptr, *tbb, size, *percpu_logout;
    unsigned char *mdt_bitmap;
    long *lp1, *lp2, sum;
    int i, cl;
    int kern_first_page;
    int mem_size = m5Conf.mem_size;

    int mem_pages = mem_size / PAGE_SIZE, cons_pages;
    ulong kernel_bytes, ksp, kernel_end, *unix_kernel_stack, bss,
        ksp_bottom, ksp_top;
    struct rpb_ctb *rpb_ctb;
    struct ctb_tt *ctb_tt;
    struct rpb_dsr *rpb_dsr;
    struct rpb_crb *rpb_crb;
    struct _m5_rpb_mdt *rpb_mdt;
    int *rpb_lurt;
    char *rpb_name;
    ulong nextPtr;

    printf_lock("memsize %x pages %x \n", mem_size, mem_pages);

    /* Allocate:
     *   two pages for the HWRPB
     *   five page table pages:
     *     1: First level page table
     *     1: Second level page table
     *     1: Third level page table for HWRPB
     *     2: Third level page table for kernel (for up to 16MB)
     * set up the page tables
     * load the kernel at the physical address 0x230000
     * build the HWRPB
     *   set up memory descriptor table to give up the
     *   physical memory between the end of the page
     *   tables and the start of the kernel
     * enable kseg addressing
     * jump to the kernel
     */

    unix_boot_mem = ROUNDUP8K(&_end);

    printf_lock("First free page after ROM 0x%x\n", unix_boot_mem);

    rpb = (struct rpb *)unix_boot_alloc(HWRPB_PAGES);

    mdt_bitmap =  (unsigned char *)unix_boot_alloc(MDT_BITMAP_PAGES);
    first = (ulong *)unix_boot_alloc(1);
    second = (ulong *)unix_boot_alloc(1);
    third_rpb = (ulong *)unix_boot_alloc(1);
    reservedFixup = (ulong*) unix_boot_alloc(1);
    third_kernel = (ulong *)unix_boot_alloc(NUM_KERNEL_THIRD);
    percpu_logout = (ulong*)unix_boot_alloc(1);

    cons_pages = KSEG_TO_PHYS(unix_boot_mem) / PAGE_SIZE;

    /* Set up the page tables */
    bzero((char *)first, PAGE_SIZE);
    bzero((char *)second, PAGE_SIZE);
    bzero((char *)reservedFixup, PAGE_SIZE);
    bzero((char *)third_rpb, HWRPB_PAGES * PAGE_SIZE);
    bzero((char *)third_kernel, PAGE_SIZE * NUM_KERNEL_THIRD);

    first[0] = KPTE(PFN(second));
    first[1] = KPTE(PFN(first)); /* Region 3 */

    /* Region 0 */
    second[SECOND(0x10000000)] = KPTE(PFN(third_rpb));

    for (i = 0; i < NUM_KERNEL_THIRD; i++) {
        /* Region 1 */
        second[SECOND(0x20000000) + i] = KPTE(PFN(third_kernel) + i);
    }

    /* Region 2 */
    second[SECOND(0x40000000)] = KPTE(PFN(second));


    /* For some obscure reason, Dec Unix's database read
     * from /etc/sysconfigtab is written to this fixed
     * mapped memory location. Go figure, since it is
     * not initialized by the console. Maybe it is
     * to look at the database from the console
     * after a boot/crash.
     *
     * Black magic to estimate the max size. SEGVs on overflow
     * bugnion
     */

#define DATABASE_BASE           0x20000000
#define DATABASE_END            0x20020000

    ulong *dbPage = (ulong*)unix_boot_alloc(1);
    bzero(dbPage, PAGE_SIZE);
    second[SECOND(DATABASE_BASE)] = KPTE(PFN(dbPage));
    for (i = DATABASE_BASE; i < DATABASE_END ; i += PAGE_SIZE) {
        ulong *db = (ulong*)unix_boot_alloc(1);
        dbPage[THIRD(i)] = KPTE(PFN(db));
    }

    /* Region 0 */
    /* Map the HWRPB */
    for (i = 0; i < HWRPB_PAGES; i++)
        third_rpb[i] = KPTE(PFN(rpb) + i);

    /* Map the MDT bitmap table */
    for (i = 0; i < MDT_BITMAP_PAGES; i++) {
        third_rpb[HWRPB_PAGES + i] = KPTE(PFN(mdt_bitmap) + i);
    }

    /* Protect the PAL pages */
    for (i = 1; i < PFN(first); i++)
        third_rpb[HWRPB_PAGES + MDT_BITMAP_PAGES + i] = KPTE(i);

   /* Set up third_kernel after it's loaded, when we know where it is */
    kern_first_page = (KSEG_TO_PHYS(m5Conf.kernStart)/PAGE_SIZE);
    kernel_end = ROUNDUP8K(m5Conf.kernEnd);
    bootadr = m5Conf.entryPoint;

    printf_lock("HWRPB 0x%x l1pt 0x%x l2pt 0x%x l3pt_rpb 0x%x l3pt_kernel 0x%x"
                " l2reserv 0x%x\n",
                rpb, first, second, third_rpb, third_kernel, reservedFixup);
    if (kernel_end - m5Conf.kernStart > (0x800000*NUM_KERNEL_THIRD)) {
        printf_lock("Kernel is more than 8MB 0x%x - 0x%x = 0x%x\n",
                    kernel_end, m5Conf.kernStart,
                    kernel_end - m5Conf.kernStart );
        panic("kernel too big\n");
    }
    printf_lock("kstart = 0x%x, kend = 0x%x, kentry = 0x%x, numCPUs = 0x%x\n", m5Conf.kernStart, m5Conf.kernEnd, m5Conf.entryPoint, m5Conf.numCPUs);
    ksp_bottom = (ulong)unix_boot_alloc(1);
    ksp_top = ksp_bottom + PAGE_SIZE;
    ptr = (ulong) ksp_bottom;
    bzero((char *)ptr, PAGE_SIZE);
    dbPage[THIRD(KSTACK_REGION_VA)] = 0;		          /* Stack Guard Page */
    dbPage[THIRD(KSTACK_REGION_VA + PAGE_SIZE)] = KPTE(PFN(ptr)); /* Kernel Stack Page */
    dbPage[THIRD(KSTACK_REGION_VA + 2*PAGE_SIZE)] = 0;		  /* Stack Guard Page */

    /* put argv into the bottom of the stack - argv starts at 1 because
     * the command thatr got us here (i.e. "unixboot) is in argv[0].
     */
    ksp = ksp_top - 8;			/* Back up one longword */
    ksp -= argc * sizeof(char *);	/* Make room for argv */
    kargv = (char **) ksp;
    for (i = 1; i < argc; i++) {	/* Copy arguments to stack */
        ksp -= ((strlen(argv[i]) + 1) + 7) & ~0x7;
        kargv[i-1] = (char *) ksp;
        strcpy(kargv[i - 1], argv[i]);
    }
    kargc = i - 1;
    kargv[kargc] = NULL;	/* just to be sure; doesn't seem to be used */
    ksp -= sizeof(char *);	/* point above last arg for no real reason */

    free_pfn = PFN(kernel_end);

    bcopy((char *)&m5_rpb, (char *)rpb, sizeof(struct rpb));

    rpb->rpb_selfref = (struct rpb *) KSEG_TO_PHYS(rpb);
    rpb->rpb_string = 0x0000004250525748;

    tbb = (ulong *) (((char *) rpb) + ROUNDUP8(sizeof(struct rpb)));
    rpb->rpb_trans_off = (ulong)tbb - (ulong)rpb;
    bcopy((char *)m5_tbb, (char *)tbb, sizeof(m5_tbb));

    /*
     * rpb_counter. Use to determine timeouts in OS.
     * XXX must be patched after a checkpoint restore (I guess)
     */

    printf_lock("CPU Clock at %d MHz IntrClockFrequency=%d \n",
                m5Conf.cpuClock, m5Conf.intrClockFrequency);
    rpb->rpb_counter = m5Conf.cpuClock * 1000 * 1000;

    /*
     * By definition, the rpb_clock is scaled by 4096 (in hz)
     */
    rpb->rpb_clock = m5Conf.intrClockFrequency * 4096;

    /*
     * Per CPU Slots. Multiprocessor support.
     */
    int percpu_size = ROUNDUP128(sizeof(struct rpb_percpu));

    printf_lock("Booting with %d processor(s) \n", m5Conf.numCPUs);

    rpb->rpb_numprocs = m5Conf.numCPUs;
    rpb->rpb_slotsize = percpu_size;
    rpb_percpu = (struct rpb_percpu *)
        ROUNDUP128(((ulong)tbb) + (sizeof(m5_tbb)));

    rpb->rpb_percpu_off = (ulong)rpb_percpu - (ulong)rpb;

    for (i = 0; i < m5Conf.numCPUs; i++) {
        struct rpb_percpu *thisCPU = (struct rpb_percpu*)
            ((ulong)rpb_percpu + percpu_size * i);

        bzero((char *)thisCPU, percpu_size);
        bcopy((char *)&m5_rpb_percpu, (char *)thisCPU,
              sizeof(struct rpb_percpu));

        thisCPU->rpb_pcb.rpb_ksp = (KSTACK_REGION_VA + 2*PAGE_SIZE - (ksp_top - ksp));
        thisCPU->rpb_pcb.rpb_ptbr = PFN(first);

        thisCPU->rpb_logout = KSEG_TO_PHYS(percpu_logout);
        thisCPU->rpb_logout_len = PAGE_SIZE;

        printf_lock("KSP: 0x%x PTBR 0x%x\n",
                    thisCPU->rpb_pcb.rpb_ksp, thisCPU->rpb_pcb.rpb_ptbr);
    }

    nextPtr = (ulong)rpb_percpu + percpu_size * m5Conf.numCPUs;

    /*
     * Console Terminal Block
     */
    rpb_ctb = (struct rpb_ctb *) nextPtr;
    ctb_tt = (struct ctb_tt*) rpb_ctb;

    rpb->rpb_ctb_off = ((ulong)rpb_ctb) - (ulong)rpb;
    rpb->rpb_ctb_size  = sizeof(struct rpb_ctb);

    bzero((char *)rpb_ctb, sizeof(struct ctb_tt));

    rpb_ctb->rpb_type = CONS_DZ;
    rpb_ctb->rpb_length = sizeof(ctb_tt) - sizeof(rpb_ctb);

    /*
     * uart initizliation
     */
    ctb_tt->ctb_tintr_vec = 0x6c0;  /* matches tlaser pal code */
    ctb_tt->ctb_rintr_vec = 0x680;  /* matches tlaser pal code */
    ctb_tt->ctb_term_type = CTB_GRAPHICS;

    rpb_crb = (struct rpb_crb *) (((ulong)rpb_ctb) + sizeof(struct ctb_tt));
    rpb->rpb_crb_off = ((ulong)rpb_crb) - (ulong)rpb;

    bzero((char *)rpb_crb, sizeof(struct rpb_crb));

    /*
     * console callback stuff (m5)
     */
    rpb_crb->rpb_num = 1;
    rpb_crb->rpb_mapped_pages = HWRPB_PAGES;
    rpb_crb->rpb_map[0].rpb_virt = 0x10000000;
    rpb_crb->rpb_map[0].rpb_phys = KSEG_TO_PHYS(((ulong)rpb) & ~0x1fff);
    rpb_crb->rpb_map[0].rpb_pgcount = HWRPB_PAGES;

    printf_lock("Console Callback at 0x%x, fixup at 0x%x, crb offset: 0x%x\n",
                rpb_crb->rpb_va_disp, rpb_crb->rpb_va_fixup, rpb->rpb_crb_off);

    rpb_mdt = (struct _m5_rpb_mdt *)((ulong)rpb_crb + sizeof(struct rpb_crb));
    rpb->rpb_mdt_off = (ulong)rpb_mdt - (ulong)rpb;
    bcopy((char *)&m5_rpb_mdt, (char *)rpb_mdt, sizeof(struct _m5_rpb_mdt));


    cl = 0;
    rpb_mdt->rpb_cluster[cl].rpb_pfncount = kern_first_page;
    cl++;

    rpb_mdt->rpb_cluster[cl].rpb_pfn = kern_first_page;
    rpb_mdt->rpb_cluster[cl].rpb_pfncount = mem_pages - kern_first_page;
    rpb_mdt->rpb_cluster[cl].rpb_pfntested =
        rpb_mdt->rpb_cluster[cl].rpb_pfncount;
    rpb_mdt->rpb_cluster[cl].rpb_pa = KSEG_TO_PHYS(mdt_bitmap);
    rpb_mdt->rpb_cluster[cl].rpb_va = 0x10000000 + HWRPB_PAGES * PAGE_SIZE;
    cl++;

    rpb_mdt->rpb_numcl = cl;

    for (i = 0; i < cl; i++)
        printf_lock("Memory cluster %d [%d - %d]\n", i,
                    rpb_mdt->rpb_cluster[i].rpb_pfn,
                    rpb_mdt->rpb_cluster[i].rpb_pfncount);

    /* Checksum the rpb for good luck */
    sum = 0;
    lp1 = (long *)&rpb_mdt->rpb_impaddr;
    lp2 = (long *)&rpb_mdt->rpb_cluster[cl];
    while (lp1 < lp2) sum += *lp1++;
    rpb_mdt->rpb_checksum = sum;

    /* XXX should checksum the cluster descriptors */
    bzero((char *)mdt_bitmap, MDT_BITMAP_PAGES * PAGE_SIZE);
    for (i = 0; i < mem_pages/8; i++)
        ((unsigned char *)mdt_bitmap)[i] = 0xff;

    printf_lock("Initalizing mdt_bitmap addr 0x%x mem_pages %x \n",
                (long)mdt_bitmap,(long)mem_pages);

    m5_rpb.rpb_config_off = 0;
    m5_rpb.rpb_fru_off = 0;

    rpb_dsr = (struct rpb_dsr *)((ulong)rpb_mdt + sizeof(struct _m5_rpb_mdt));
    rpb->rpb_dsr_off = (ulong)rpb_dsr - (ulong)rpb;
    bzero((char *)rpb_dsr, sizeof(struct rpb_dsr));
    rpb_dsr->rpb_smm = 1578; /* Official XXM SMM number as per SRM */
    rpb_dsr->rpb_smm = 1089; /* Official Alcor SMM number as per SRM */

    rpb_lurt = (int *) ROUNDUP8((ulong)rpb_dsr + sizeof(struct rpb_dsr));
    rpb_dsr->rpb_lurt_off = ((ulong) rpb_lurt) - (ulong) rpb_dsr;
    bcopy((char *)m5_lurt, (char *)rpb_lurt, sizeof(m5_lurt));

    rpb_name = (char *) ROUNDUP8(((ulong)rpb_lurt) + sizeof(m5_lurt));
    rpb_dsr->rpb_sysname_off = ((ulong) rpb_name) - (ulong) rpb_dsr;
#define THENAME "             M5/Alpha       "
    sum = sizeof(THENAME);
    bcopy(THENAME, rpb_name, sum);
    *(ulong *)rpb_name = sizeof(THENAME); /* put in length field */

    /* calculate size of rpb */
    rpb->rpb_size = ((ulong) &rpb_name[sum]) - (ulong)rpb;

    if (rpb->rpb_size > PAGE_SIZE * HWRPB_PAGES) {
        panic("HWRPB_PAGES=%d too small for HWRPB !!! \n");
    }

    ulong *rpbptr = (ulong*)((char*)rpb_dsr + sizeof(struct rpb_dsr));
    rpb_crb->rpb_pa_disp = KSEG_TO_PHYS(rpbptr);
    rpb_crb->rpb_va_disp = 0x10000000 +
        (((ulong)rpbptr - (ulong)rpb) & (0x2000 * HWRPB_PAGES - 1));
    printf_lock("ConsoleDispatch at virt %x phys %x val %x\n",
                rpb_crb->rpb_va_disp, rpb_crb->rpb_pa_disp, consoleCallback);
    *rpbptr++ = 0;
    *rpbptr++ = (ulong) consoleCallback;
    rpb_crb->rpb_pa_fixup = KSEG_TO_PHYS(rpbptr);
    rpb_crb->rpb_va_fixup = 0x10000000 +
        (((ulong)rpbptr - (ulong)rpb) & (0x2000 * HWRPB_PAGES - 1));
    *rpbptr++ = 0;

    *rpbptr++ = (ulong) consoleFixup;

    /* Checksum the rpb for good luck */
    sum = 0;
    lp1 = (long *)rpb;
    lp2 = &rpb->rpb_checksum;
    while (lp1 < lp2)
        sum += *lp1++;
    *lp2 = sum;

  /*
   * MP bootstrap
   */
    for (i = 1; i < m5Conf.numCPUs; i++) {
        ulong stack = (ulong)unix_boot_alloc(1);
        printf_lock("Bootstraping CPU %d with sp=0x%x\n", i, stack);
        m5AlphaAccess->bootStrapImpure = stack;
        m5AlphaAccess->bootStrapCPU = i;
    }

    /*
     * Make sure that we are not stepping on the kernel
     */
    if ((ulong)unix_boot_mem >= (ulong)m5Conf.kernStart) {
        panic("CONSOLE: too much memory. Smashing kernel\n");
    } else {
        printf_lock("unix_boot_mem ends at %x \n", unix_boot_mem);
    }

    JToKern((char *)bootadr, (ulong)rpb_percpu, free_pfn, kargc, kargv, NULL);
}


void
JToKern(char *bootadr, ulong rpb_percpu, ulong free_pfn, ulong k_argc,
        char **k_argv, char **envp)
{
    extern ulong palJToKern[];

    struct _kernel_params *kernel_params = (struct _kernel_params *) KSEG;
    int i;

    printf_lock("k_argc = %d ", k_argc);
    for (i = 0; i < k_argc; i++) {
        printf_lock("'%s' ", k_argv[i]);
    }
    printf_lock("\n");

    kernel_params->bootadr = bootadr;
    kernel_params->rpb_percpu = KSEG_TO_PHYS(rpb_percpu);
    kernel_params->free_pfn = free_pfn;
    kernel_params->argc = k_argc;
    kernel_params->argv = (ulong)k_argv;
    kernel_params->envp = (ulong)envp;
    printf_lock("jumping to kernel at 0x%x, (PCBB 0x%x pfn %d)\n",
                bootadr, rpb_percpu, free_pfn);
    JToPal(KSEG_TO_PHYS(palJToKern));
    printf_lock("returned from JToPal. Looping\n");
    while (1)
        continue;
}

void
JToPal(ulong bootadr)
{
    cServe(bootadr, 0, CSERVE_K_JTOPAL);

    /*
     * Make sure that floating point is enabled incase
     * it was disabled by the user program.
     */
    wrfen(1);
}

int
strcpy(char *dst, char *src)
{
    int i = 0;
    while (*src) {
        *dst++ = *src++;
        i++;
    }
    return i;
}

/*
 * Console I/O
 *
 */

int numOpenDevices = 11;
struct {
    char name[128];
} deviceState[32];

#define BOOTDEVICE_NAME "SCSI 1 0 0 1 100 0"

void
DeviceOperation(long op, long channel, long count, long address, long block)
{
    long pAddr;

    if (strcmp(deviceState[channel].name, BOOTDEVICE_NAME )) {
        panic("DeviceRead: only implemented for root disk \n");
    }
    pAddr = KSEG_TO_PHYS(address);
    if (pAddr + count > m5Conf.mem_size) {
        panic("DeviceRead: request out of range \n");
    }

    m5AlphaAccess->diskCount = count;
    m5AlphaAccess->diskPAddr = pAddr;
    m5AlphaAccess->diskBlock = block;
    m5AlphaAccess->diskOperation = op; /* launch */
}

/*
 * M5 Console callbacks
 *
 */

/* AXP manual 2-31 */
#define CONSCB_GETC 0x1
#define CONSCB_PUTS 0x2
#define CONSCB_RESET_TERM 0x3
#define CONSCB_SET_TERM_INT 0x4
#define CONSCB_SET_TERM_CTL 0x5
#define CONSCB_PROCESS_KEY 0x6
#define CONSCB_OPEN_CONSOLE 0x7
#define CONSCB_CLOSE_CONSOLE 0x8

#define CONSCB_OPEN 0x10
#define CONSCB_CLOSE 0x11
#define CONSCB_READ 0x13

#define CONSCB_GETENV 0x22

/* AXP manual 2-26 */
#define	ENV_AUTO_ACTION		0X01
#define	ENV_BOOT_DEV		0X02
#define	ENV_BOOTDEF_DEV		0X03
#define	ENV_BOOTED_DEV		0X04
#define	ENV_BOOT_FILE		0X05
#define	ENV_BOOTED_FILE		0X06
#define	ENV_BOOT_OSFLAGS	0X07
#define	ENV_BOOTED_OSFLAGS	0X08
#define	ENV_BOOT_RESET		0X09
#define	ENV_DUMP_DEV		0X0A
#define	ENV_ENABLE_AUDIT	0X0B
#define	ENV_LICENSE		0X0C
#define	ENV_CHAR_SET		0X0D
#define	ENV_LANGUAGE		0X0E
#define	ENV_TTY_DEV		0X0F
#define	ENV_SCSIID		0X42
#define	ENV_SCSIFAST		0X43
#define	ENV_COM1_BAUD		0X44
#define	ENV_COM1_MODEM		0X45
#define	ENV_COM1_FLOW		0X46
#define	ENV_COM1_MISC		0X47
#define	ENV_COM2_BAUD		0X48
#define	ENV_COM2_MODEM		0X49
#define	ENV_COM2_FLOW		0X4A
#define	ENV_COM2_MISC		0X4B
#define	ENV_PASSWORD		0X4C
#define	ENV_SECURE		0X4D
#define	ENV_LOGFAIL		0X4E
#define	ENV_SRM2DEV_ID		0X4F

#define MAX_ENVLEN 32

char env_auto_action[MAX_ENVLEN]	= "BOOT";
char env_boot_dev[MAX_ENVLEN]		= "";
char env_bootdef_dev[MAX_ENVLEN]	= "";
char env_booted_dev[MAX_ENVLEN]		= BOOTDEVICE_NAME;
char env_boot_file[MAX_ENVLEN]		= "";
char env_booted_file[MAX_ENVLEN]	= "";
char env_boot_osflags[MAX_ENVLEN]	= "";
char env_booted_osflags[MAX_ENVLEN]	= "";
char env_boot_reset[MAX_ENVLEN]		= "";
char env_dump_dev[MAX_ENVLEN]		= "";
char env_enable_audit[MAX_ENVLEN]	= "";
char env_license[MAX_ENVLEN]		= "";
char env_char_set[MAX_ENVLEN]		= "";
char env_language[MAX_ENVLEN]		= "";
char env_tty_dev[MAX_ENVLEN]		= "0";
char env_scsiid[MAX_ENVLEN]		= "";
char env_scsifast[MAX_ENVLEN]		= "";
char env_com1_baud[MAX_ENVLEN]		= "";
char env_com1_modem[MAX_ENVLEN]		= "";
char env_com1_flow[MAX_ENVLEN]		= "";
char env_com1_misc[MAX_ENVLEN]		= "";
char env_com2_baud[MAX_ENVLEN]		= "";
char env_com2_modem[MAX_ENVLEN]		= "";
char env_com2_flow[MAX_ENVLEN]		= "";
char env_com2_misc[MAX_ENVLEN]		= "";
char env_password[MAX_ENVLEN]		= "";
char env_secure[MAX_ENVLEN]		= "";
char env_logfail[MAX_ENVLEN]		= "";
char env_srm2dev_id[MAX_ENVLEN]		= "";

#define MAX_ENV_INDEX 100
char *envptr[MAX_ENV_INDEX] = {
    0,					/* 0x00 */
    env_auto_action,			/* 0x01 */
    env_boot_dev,			/* 0x02 */
    env_bootdef_dev,			/* 0x03 */
    env_booted_dev,			/* 0x04 */
    env_boot_file,			/* 0x05 */
    env_booted_file,			/* 0x06 */
    env_boot_osflags,			/* 0x07 */
    env_booted_osflags,			/* 0x08 */
    env_boot_reset,			/* 0x09 */
    env_dump_dev,			/* 0x0A */
    env_enable_audit,			/* 0x0B */
    env_license,			/* 0x0C */
    env_char_set,			/* 0x0D */
    (char *)&env_language,		/* 0x0E */
    env_tty_dev,			/* 0x0F */
    0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,	/* 0x10 - 0x1F */
    0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,	/* 0x20 - 0x2F */
    0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,	/* 0x30 - 0x3F */
    0,					/* 0x40 */
    0,					/* 0x41 */
    env_scsiid,				/* 0x42 */
    env_scsifast,			/* 0x43 */
    env_com1_baud,			/* 0x44 */
    env_com1_modem,			/* 0x45 */
    env_com1_flow,			/* 0x46 */
    env_com1_misc,			/* 0x47 */
    env_com2_baud,			/* 0x48 */
    env_com2_modem,			/* 0x49 */
    env_com2_flow,			/* 0x4A */
    env_com2_misc,			/* 0x4B */
    env_password,			/* 0x4C */
    env_secure,				/* 0x4D */
    env_logfail,			/* 0x4E */
    env_srm2dev_id,			/* 0x4F */
    0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,	/* 0x50 - 0x5F */
    0,					/* 0x60 */
    0,					/* 0x61 */
    0,					/* 0x62 */
    0,					/* 0x63 */
};

long
CallBackDispatcher(long a0, long a1, long a2, long a3, long a4)
{
    long i;
    switch (a0) {
      case CONSCB_GETC:
        return GetChar();

      case CONSCB_PUTS:
        for (i = 0; i < a3; i++)
            PutChar(*((char *)a2 + i));
        return a3;

      case CONSCB_GETENV:
        if (a1 >= 0 && a1 < MAX_ENV_INDEX && envptr[a1] != 0 && *envptr[a1]) {
            i = strcpy((char*)a2, envptr[a1]);
        } else {
            strcpy((char*)a2, "");
            i = (long)0xc000000000000000;
            if (a1 >= 0 && a1 < MAX_ENV_INDEX)
                printf_lock("GETENV unsupported option %d (0x%x)\n", a1, a1);
            else
                printf_lock("GETENV unsupported option %s\n", a1);
        }

        if (i > a3)
            panic("CONSCB_GETENV overwrote buffer\n");
        return i;

      case CONSCB_OPEN:
        bcopy((char*)a1, deviceState[numOpenDevices].name, a2);
        deviceState[numOpenDevices].name[a2] = '\0';
        printf_lock("CONSOLE OPEN : %s --> success \n",
                    deviceState[numOpenDevices].name);
        return numOpenDevices++;

      case CONSCB_READ:
        DeviceOperation(a0, a1, a2, a3, a4);
        break;

      case CONSCB_CLOSE:
        break;

      case CONSCB_OPEN_CONSOLE:
        printf_lock("CONSOLE OPEN\n");
        return 0; /* success */
        break; /* not reached */

      case CONSCB_CLOSE_CONSOLE:
        printf_lock("CONSOLE CLOSE\n");
        return 0; /* success */
        break; /* not reached */

      default:
        panic("CallBackDispatcher(%x,%x,%x,%x,%x)\n", a0, a1, a2, a3, a4);
    }

    return 0;
}

long
CallBackFixup(int a0, int a1, int a2)
{
    long temp;
    /*
     * Linux uses r8 for the current pointer (pointer to data
     * structure contating info about currently running process). It
     * is set when the kernel starts and is expected to remain
     * there... Problem is that the unlike the kernel, the console
     * does not prevent the assembler from using r8. So here is a work
     * around. So far this has only been a problem in CallBackFixup()
     * but any other call back functions couldd cause a problem at
     * some point
     */

    /* save off the current pointer to a temp variable */
    asm("bis $8, $31, %0" : "=r" (temp));

    /* call original code */
    printf_lock("CallbackFixup %x %x, t7=%x\n", a0, a1, temp);

    /* restore the current pointer */
    asm("bis %0, $31, $8" : : "r" (temp) : "$8");

    return 0;
}

void
SlaveCmd(int cpu, struct rpb_percpu *my_rpb)
{
    extern ulong palJToSlave[];

    printf_lock("Slave CPU %d console command %s", cpu,
                my_rpb->rpb_iccb.iccb_rxbuf);

    my_rpb->rpb_state |= STATE_BIP;
    my_rpb->rpb_state &= ~STATE_RC;

    printf_lock("SlaveCmd: restart %x %x vptb %x my_rpb %x my_rpb_phys %x\n",
                rpb->rpb_restart, rpb->rpb_restart_pv, rpb->rpb_vptb, my_rpb,
                KSEG_TO_PHYS(my_rpb));

    cServe(KSEG_TO_PHYS(palJToSlave), (ulong)rpb->rpb_restart,
           CSERVE_K_JTOPAL, rpb->rpb_restart_pv, rpb->rpb_vptb,
           KSEG_TO_PHYS(my_rpb));

    panic("SlaveCmd returned \n");
}

void
SlaveLoop(int cpu)
{
    int size = ROUNDUP128(sizeof(struct rpb_percpu));
    struct rpb_percpu *my_rpb = (struct rpb_percpu*)
        ((ulong)rpb_percpu + size * cpu);

    if (cpu == 0) {
        panic("CPU 0 entering slaveLoop. Reenetering the console. HOSED\n");
    } else {
        printf_lock("Entering slaveloop for cpu %d my_rpb=%x\n", cpu, my_rpb);
    }

    // swap the processors context to the one in the
    // rpb_percpu struct very carefully (i.e. no stack usage)
    // so that linux knows which processor ends up in __smp_callin
    // and we don't trash any data is the process
    SlaveSpin(cpu, my_rpb, &my_rpb->rpb_iccb.iccb_rxlen);
}