summaryrefslogtreecommitdiff
path: root/system/alpha/console/console.c
diff options
context:
space:
mode:
authorLisa Hsu <hsul@eecs.umich.edu>2003-11-14 10:52:42 -0500
committerLisa Hsu <hsul@eecs.umich.edu>2003-11-14 10:52:42 -0500
commitb8612cbda3625e27f109469a1f5416237c97fb41 (patch)
treee4d195ed22ab29000f1bcada6a560386b6fd1f8f /system/alpha/console/console.c
parent488280e48b5f227b2eb35df5d6daba2ae94a1de6 (diff)
downloadgem5-b8612cbda3625e27f109469a1f5416237c97fb41.tar.xz
Import changeset
Diffstat (limited to 'system/alpha/console/console.c')
-rw-r--r--system/alpha/console/console.c1126
1 files changed, 1126 insertions, 0 deletions
diff --git a/system/alpha/console/console.c b/system/alpha/console/console.c
new file mode 100644
index 000000000..c6a61a10e
--- /dev/null
+++ b/system/alpha/console/console.c
@@ -0,0 +1,1126 @@
+
+
+/* ******************************************
+ * SimOS SRM Console
+ *
+ * Derived from Lance Berc's SRM console
+ * for the SRC XXM Machine
+ * ******************************************/
+
+
+/* from simos */
+typedef unsigned long long uint64;
+#include "machine_defs.h"
+#include "new_aouthdr.h"
+#include "alpha_access.h"
+#if 0
+#include "srcmax.h"
+#endif
+
+/* from ../h */
+#include "lib.h"
+#include "rpb.h"
+#include "cserve.h"
+
+
+#define CONS_INT_TX 0x01 /* interrupt enable / state bits */
+#define CONS_INT_RX 0x02
+
+#define KSEG 0xfffffc0000000000
+#define K1BASE 0xfffffc8000000000
+#define KSEG_TO_PHYS(x)(((ul)x) & ~KSEG)
+
+#define CDR ((volatile DevConsoleRegisters *) \
+ (__MAGIC_ZONE(0, 0, MAGIC_ZONE_BDOOR_DEV) + __MAGIC_BDOOR_CNSLE_OFFS))
+
+
+#define PHYS_TO_K1(_x) (K1BASE|(_x))
+
+#define AOUT_LOAD_ADDR (KSEG|0xf000)
+
+#define ROUNDUP8(x) ((ul)(((ul)x)+7) & ~7)
+#define ROUNDUP128(x) ((ul)(((ul)x)+127) & ~127)
+#define ROUNDUP8K(x) ((ul)(((ul)(x))+8191) & ~8191)
+
+#define FIRST(x) ((((ul)(x)) >> 33) & 0x3ff)
+#define SECOND(x) ((((ul)(x)) >> 23) & 0x3ff)
+#define THIRD(x) ((((ul)(x)) >> 13) & 0x3ff)
+#define THIRD_XXX(x) ((((ul)(x)) >> 13) & 0xfff)
+#define PFN(x) ((((ul)(x) & ~KSEG) >> 13))
+
+/* Kernel write | kernel read | valid */
+#define KPTE(x) ((ul)((((ul)(x)) << 32) | 0x1101))
+
+#define HWRPB_PAGES 4
+#define MDT_BITMAP_PAGES 4
+
+#define CSERVE_K_JTOKERN 0x18
+
+#define NUM_KERNEL_THIRD (4)
+
+
+static unixBoot(int go, int argc, char **argv);
+void jToPal(ul bootadr);
+void SlaveLoop(int cpu);
+
+
+AlphaAccess simosConf;
+
+/* **************************************************************
+ * Console callbacks use VMS calling conventions
+ * read AXP manual, 2-64.
+ * ***************************************************************/
+typedef struct OpenVMSFunc {
+ long dummy;
+ long func;
+}OpenVMSFunc;
+
+OpenVMSFunc callbackFunc, fixupFunc;
+
+
+
+
+ul theLock;
+
+
+extern void SpinLock(ul *lock);
+#define SpinUnlock(_x) *(_x) = 0;
+
+struct _kernel_params {
+ char *bootadr;
+ ul rpb_percpu;
+ ul free_pfn;
+ ul argc;
+ ul argv;
+ ul envp; /* NULL */
+};
+
+
+extern consoleCallback[];
+extern consoleFixup[];
+long CallBackDispatcher();
+long CallBackFixup();
+
+/*
+ * simos console output
+ */
+
+void InitConsole(void)
+{
+#if 0
+ CDR->intr_status =(DevRegister)(DEV_CNSLE_RX_INTR |DEV_CNSLE_TX_INTR);
+#endif
+}
+
+void PutChar(char c)
+{
+#if 0
+ CDR->data = c;
+#endif
+#if 0
+ *(int*) PHYS_TO_K1(SLOT_D_COM1<<5) = c;
+#endif
+ AlphaAccess *k1Conf = (AlphaAccess *)(__MAGIC_ZONE(0, 0, MAGIC_ZONE_EV5_ALIAS));
+ k1Conf->outputChar = c;
+
+}
+
+
+int passArgs(int argc)
+{
+ ;
+}
+
+
+main(int argc, char **argv)
+{
+ int x,i;
+ AlphaAccess *k1Conf = (AlphaAccess *)(__MAGIC_ZONE(0, 0, MAGIC_ZONE_EV5_ALIAS));
+ ui *k1ptr,*ksegptr;
+
+
+ InitConsole();
+ printf("SimOS console \n");
+ /*
+ * get configuration from backdoor
+ */
+ simosConf.last_offset = k1Conf->last_offset;
+ printf(" Got simosConfiguration %d \n",simosConf.last_offset);
+
+ for (i=1;i<=simosConf.last_offset/4;i++) {
+ ui *k1ptr = (ui*)k1Conf + i;
+ ui *ksegptr = (ui*)(&simosConf.last_offset)+i;
+ *ksegptr = *k1ptr;
+
+ }
+
+ if (simosConf.version != ALPHA_ACCESS_VERSION) {
+ panic("Console version mismatch. Console expects %d. SimOS has %d \n",
+ ALPHA_ACCESS_VERSION,simosConf.version);
+ }
+
+
+ /*
+ * setup arguments to kernel
+ */
+ unixBoot(1,argc,argv);
+
+ x = *(volatile int *)(K1BASE-4);
+ while(1) continue;
+ return x;
+}
+
+/*
+ * BOOTING
+ */
+struct rpb xxm_rpb = {
+ NULL, /* 000: physical self-reference */
+ 'H'|('W'<<8)|('R'<<16)|('P'<<24)|('B'<<32), /* 008: contains string "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 */
+ 8192, /* 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 */
+#ifdef undef
+/* To be legitimate, the following system type and variation are correct for the XXM.
+ But there are too many #ifdefs etc to deal with in Unix, so we tell the kernel
+ that we're an Avanti, which is similar enough.
+ */
+ 31, /* 050: system type - XXM is now in the Alpha SRM */
+ (1 << 10) | (2<<1),/* 058: system variation - XXM w/EV5 & embeded console */
+#endif
+#if 0
+ 0x12, /* 050: system type - masquarade as some random 21064 */
+#endif
+ 12, /* masquerade a DEC_3000_500 (bugnion) */
+ (2<<1), /* 058: system variation */
+ 'c'|('o'<<8)|('o'<<16)|('l'<< 24), /* 060: system revision */
+ 1024*4096, /* 068: scaled interval clock intr freq OVERRIDEN*/
+ 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 */
+#ifdef bugnion_gone
+ sizeof(struct rpb_ctb), /* 0B0: bytes in largest CTB */
+#else
+ sizeof(struct ctb_tt),
+#endif
+ 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 */
+};
+
+ul xxm_tbb[] = { 0x1e1e1e1e1e1e1e1e, 0x1e1e1e1e1e1e1e1e, 0x1e1e1e1e1e1e1e1e, 0x1e1e1e1e1e1e1e1e,
+ 0x1e1e1e1e1e1e1e1e, 0x1e1e1e1e1e1e1e1e, 0x1e1e1e1e1e1e1e1e, 0x1e1e1e1e1e1e1e1e};
+
+struct rpb_percpu xxm_rpb_percpu = {
+ {0,0,0,0,0,0,0,{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: phys addr of palcode mem space */
+ 0x2000, /* 0A0: phys addr of palcode scratch space */
+ (2 << 16) | (5 << 8) | 1, /* 0A8: PALcode rev required */
+ 5|(2<<32), /* 0B0: processor type */
+ 7, /* 0B8: processor variation */
+ 'D'|('a'<<8)|('v'<<16)|('e'<<24), /* 0C0: processor revision */
+ {'D','a','v','e','C','o','n','r','o','y',0,0,0,0,0,0}, /* 0C8: proc serial num: 10 ascii chars */
+ 0, /* 0D8: phys addr of logout area */
+ 0, /* 0E0: length 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 communications 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 _xxm_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 _xxm_rpb_mdt xxm_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 xxm_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 xxm_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 {
+ unsigned long length;
+ char name[16];
+};
+
+extern struct _rpb_name xxm_name;
+
+struct rpb_dsr xxm_rpb_dsr = {
+ 0,
+ 0,
+ 0,
+};
+
+struct _rpb_name xxm_name = {
+ 16,
+ {'D','E','C',' ','S','R','C',' ','X','X','M',' ','D','G','C',0},
+};
+
+/* XXM has one LURT entry - 1050 is for workstations, 1100 is servers (and is needed for CXX) */
+long xxm_lurt[10] = { 9, 12, -1, -1, -1, -1, -1, -1, 1100, 1100 };
+
+ul unix_boot_mem;
+unsigned long bootadr;
+#if 0
+unsigned long aout_bss_addr, aout_bss_size, aout_entry, aout_text_start, aout_data_addr;
+#endif
+char **kargv;
+int kargc;
+ul free_pfn;
+struct rpb_percpu *rpb_percpu;
+
+
+#define MAX_CPUS 32
+
+ul bootStrapImpure[MAX_CPUS];
+
+
+char *unix_boot_alloc(int pages)
+{
+ char *ret = (char *) unix_boot_mem;
+ unix_boot_mem += (pages * 8192);
+ return ret;
+}
+
+ul *first = 0;
+ul *third_rpb = 0;
+ul *reservedFixup = 0;
+
+struct rpb *rpb;
+
+unixBoot(int go, int argc, char **argv)
+{
+ ul *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 = simosConf.mem_size;
+
+ int mem_pages = mem_size / 8192, cons_pages;
+ ul 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 _xxm_rpb_mdt *rpb_mdt;
+ int *rpb_lurt;
+ char *rpb_name;
+ ul nextPtr;
+
+ printf( "memsize %x pages %x \n",mem_size,mem_pages);
+
+
+
+#ifdef notnow
+ if (unixArgs()) return;
+#endif
+
+ /* 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("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 = (ul *)unix_boot_alloc(1);
+ second = (ul *)unix_boot_alloc(1);
+ third_rpb = (ul *)unix_boot_alloc(1);
+ reservedFixup = (ul*) unix_boot_alloc(1);
+ third_kernel = (ul *)unix_boot_alloc(NUM_KERNEL_THIRD);
+ percpu_logout = (ul*)unix_boot_alloc(1);
+
+
+ cons_pages = KSEG_TO_PHYS(unix_boot_mem) / 8192;
+
+ /* Set up the page tables */
+ bzero((char *)first, 8192);
+ bzero((char *)second, 8192);
+ bzero((char *)reservedFixup,8192);
+ bzero((char *)third_rpb, HWRPB_PAGES * 8192);
+ bzero((char *)third_kernel, 8192 * NUM_KERNEL_THIRD);
+
+ first[0] = KPTE(PFN(second));
+ first[1] = KPTE(PFN(first)); /* Region 3 */
+
+ second[SECOND(0x10000000)] = KPTE(PFN(third_rpb)); /* Region 0 */
+ for (i=0;i<NUM_KERNEL_THIRD;i++) {
+ second[SECOND(0x20000000)+i] = KPTE(PFN(third_kernel)+i); /* Region 1 */
+ }
+ second[SECOND(0x40000000)] = KPTE(PFN(second)); /* Region 2 */
+
+
+ {
+
+ /* 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
+#ifdef not_not
+#define DATABASE_END 0x20230000 /* don't need all that */
+#endif
+
+#define DATABASE_END 0x20020000
+
+ int i;
+ ul *dbPage = (ul*)unix_boot_alloc(1);
+ second[SECOND(DATABASE_BASE)] = KPTE(PFN(dbPage));
+ for (i=DATABASE_BASE; i <DATABASE_END ; i+= 8096) {
+ ul *db = (ul*)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 */
+
+#ifdef original__xxm
+ if (unixLoadKernel(AOUT_LOAD_ADDR, argv[1]) == -1) return;
+ aoutfixup(AOUT_LOAD_ADDR);
+#else
+ /* aoutfixup(simosConf.kernelFileHdr); */
+#endif
+#if 0
+ bss = aout_bss_addr;
+
+ kern_first_page = (KSEG_TO_PHYS(aout_text_start) / 8192);
+ kernel_end = ksp_top = ROUNDUP8K(aout_bss_addr + aout_bss_size);
+ bootadr = aout_entry;
+#endif
+
+ kern_first_page = (KSEG_TO_PHYS(simosConf.kernStart)/8192);
+ kernel_end = ksp_top = ROUNDUP8K(simosConf.kernEnd);
+ bootadr = simosConf.entryPoint;
+
+
+ printf("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 - simosConf.kernStart > (0x800000*NUM_KERNEL_THIRD)) {
+ printf("Kernel is more than 8MB 0x%x - 0x%x = 0x%x\n",
+ kernel_end, simosConf.kernStart,
+ kernel_end -simosConf.kernStart );
+ panic("kernel too big\n");
+
+ }
+ /* Map the kernel's pages into the third level of region 2 */
+
+ for (ptr = simosConf.kernStart; ptr < kernel_end; ptr += 8192) {
+
+ third_kernel[THIRD_XXX(ptr)] = KPTE(PFN(ptr));
+ }
+ /* blow 2 pages of phys mem for guards since it maintains 1-to-1 mapping */
+ ksp = ksp_top + (3 * 8192);
+ if (ksp - simosConf.kernStart > (0x800000*NUM_KERNEL_THIRD)) {
+ printf("Kernel stack pushd us over 8MB\n");
+ panic("ksp too big\n");
+ }
+ if (THIRD_XXX((ul)ksp_top) > NUM_KERNEL_THIRD * 1024) {
+ panic("increase NUM_KERNEL_THIRD, and change THIRD_XXX\n");
+ }
+ ptr = (ul) ksp_top;
+ bzero((char *)ptr, 8192 * 2);
+ third_kernel[THIRD_XXX(ptr)] = 0; /* Stack Guard Page */
+ ptr += 8192;
+ third_kernel[THIRD_XXX(ptr)] = KPTE(PFN(ptr)); /* Kernel Stack Pages */
+ ptr += 8192;
+ third_kernel[THIRD_XXX(ptr)] = KPTE(PFN(ptr));
+ ptr += 8192;
+ third_kernel[THIRD_XXX(ptr)] = 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 -= 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(ptr);
+
+ bcopy((char *)&xxm_rpb, (char *)rpb, sizeof(struct rpb));
+
+ rpb->rpb_selfref = (struct rpb *) KSEG_TO_PHYS(rpb);
+ rpb->rpb_string = 0x0000004250525748;
+
+ tbb = (ul *) (((char *) rpb) + ROUNDUP8(sizeof(struct rpb)));
+ rpb->rpb_trans_off = (ul)tbb - (ul)rpb;
+ bcopy((char *)xxm_tbb, (char *)tbb, sizeof(xxm_tbb));
+
+
+ /*
+ * rpb_counter. Use to determine timeouts in OS.
+ * XXX must be patched after a checkpoint restore (I guess)
+ */
+
+ printf("CPU Clock at %d MHz IntrClockFrequency=%d \n", simosConf.cpuClock,simosConf.intrClockFrequency);
+ rpb->rpb_counter = simosConf.cpuClock * 1000 * 1000;
+
+ /*
+ * By definition, the rpb_clock is scaled by 4096 (in hz)
+ */
+ rpb->rpb_clock = simosConf.intrClockFrequency * 4096;
+
+
+
+ /*
+ * Per CPU Slots. Multiprocessor support.
+ */
+ {
+ int i;
+ int size = ROUNDUP128(sizeof(struct rpb_percpu));
+
+ printf("Booting with %d processor(s) \n",simosConf.numCPUs);
+
+ rpb->rpb_numprocs = simosConf.numCPUs;
+ rpb->rpb_slotsize = size;
+ rpb_percpu = (struct rpb_percpu *)
+ ROUNDUP128(((ul) tbb) +(sizeof(xxm_tbb)));
+
+ rpb->rpb_percpu_off = (ul)rpb_percpu - (ul)rpb;
+
+ for (i=0;i<simosConf.numCPUs;i++) {
+ struct rpb_percpu *thisCPU = (struct rpb_percpu*)
+ ((ul)rpb_percpu + size*i);
+
+ bzero((char *)thisCPU, size);
+ bcopy((char *)&xxm_rpb_percpu,
+ (char *)thisCPU,
+ sizeof(struct rpb_percpu));
+
+ thisCPU->rpb_pcb.rpb_ksp = ksp;
+ thisCPU->rpb_pcb.rpb_ptbr = PFN(first);
+
+ thisCPU->rpb_logout = KSEG_TO_PHYS(percpu_logout);
+ thisCPU->rpb_logout_len = 8192;
+
+/* thisCPU->rpb_pcb.rpb_ptbr = PFN(second);*/
+
+ printf("KSP: 0x%x PTBR 0x%x\n", thisCPU->rpb_pcb.rpb_ksp, thisCPU->rpb_pcb.rpb_ptbr);
+
+ if (i) {
+ bootStrapImpure[i] = (ul)unix_boot_alloc(1);
+ }
+
+ }
+
+ nextPtr = (ul)rpb_percpu + size*simosConf.numCPUs;
+ }
+
+ /*
+ * Console Terminal Block
+ */
+
+
+ rpb_ctb = (struct rpb_ctb *) nextPtr;
+ ctb_tt = (struct ctb_tt*) rpb_ctb;
+
+ rpb->rpb_ctb_off = ((ul)rpb_ctb) - (ul)rpb;
+ rpb->rpb_ctb_size = sizeof(struct rpb_ctb);
+
+ bzero((char *)rpb_ctb, sizeof(struct ctb_tt));
+
+#ifdef original_xxm
+ if (tga_slot == -1)
+ rpb_ctb->rpb_type = CONS_DZ;
+ else {
+ rpb_ctb->rpb_type = CONS_GRPH;
+ rpb_ctb->rpb_unit = (SLOTINFO_PCI << 16) | (0 << 8) | tga_slot;
+ }
+#else
+ rpb_ctb->rpb_type = CONS_DZ;
+#endif
+
+ rpb_ctb->rpb_length = sizeof(ctb_tt)-sizeof(rpb_ctb);
+
+ /*
+ * uart initizliation
+ */
+ ctb_tt->ctb_csr = 0;
+ ctb_tt->ctb_tivec = 0x6c0; /* matches tlaser pal code */
+ ctb_tt->ctb_rivec = 0x680; /* matches tlaser pal code */
+ ctb_tt->ctb_baud = 9600;
+ ctb_tt->ctb_put_sts = 0;
+ ctb_tt->ctb_get_sts = 0;
+
+
+ rpb_crb = (struct rpb_crb *) (((ul)rpb_ctb) + sizeof(struct ctb_tt));
+ rpb->rpb_crb_off = ((ul)rpb_crb) - (ul)rpb;
+
+ bzero((char *)rpb_crb, sizeof(struct rpb_crb));
+ /*
+ * console callback stuff (simos)
+ */
+
+ 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 = ((ul)rpb) & ~0x1fff;
+ rpb_crb->rpb_map[0].rpb_pgcount = HWRPB_PAGES;
+
+
+ printf("Console Callback at 0x%x, fixup at 0x%x \n",
+ rpb_crb->rpb_va_disp,
+ rpb_crb->rpb_va_fixup );
+
+ rpb_mdt = (struct _xxm_rpb_mdt *) (((ul)rpb_crb) + sizeof(struct rpb_crb));
+ rpb->rpb_mdt_off = (ul)rpb_mdt - (ul)rpb;
+ bcopy((char *)&xxm_rpb_mdt, (char *)rpb_mdt, sizeof(struct _xxm_rpb_mdt));
+
+
+ cl = 0;
+#ifdef undef
+ /* Until Digital Unix can handle it, account all pages below the kernel
+ * as "console" memory. */
+ rpb_mdt->rpb_cluster[cl].rpb_pfncount = cons_pages;
+#endif
+ 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 * 8192;
+ cl++;
+
+#ifdef undef
+ /* The stupid Unix kernel needs to have all mdt clusters in ascending
+ * order, and the last cluster is used to compute the top of memory.
+ * It can't make use of memory between the console and the kernel.
+ */
+ rpb_mdt->rpb_cluster[cl].rpb_pfn = cons_pages;
+ rpb_mdt->rpb_cluster[cl].rpb_pfncount = kern_first_page - cons_pages;
+ 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 * 8192;
+ cl++;
+#endif
+
+ rpb_mdt->rpb_numcl = cl;
+
+ for (i = 0; i < cl; i++)
+ printf("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 * 8192);
+ for (i = 0; i < mem_pages/8; i++) ((unsigned char *)mdt_bitmap)[i] = 0xff;
+
+ printf("Initalizing mdt_bitmap addr 0x%x mem_pages %x \n",
+ (long)mdt_bitmap,(long)mem_pages);
+
+ xxm_rpb.rpb_config_off = 0;
+ xxm_rpb.rpb_fru_off = 0;
+
+ rpb_dsr = (struct rpb_dsr *) (((ul)rpb_mdt) + sizeof(struct _xxm_rpb_mdt));
+ rpb->rpb_dsr_off = ((ul)rpb_dsr) - (ul)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(((ul)rpb_dsr) + sizeof(struct rpb_dsr));
+ rpb_dsr->rpb_lurt_off = ((ul) rpb_lurt) - (ul) rpb_dsr;
+ bcopy((char *)xxm_lurt, (char *)rpb_lurt, sizeof(xxm_lurt));
+
+ rpb_name = (char *) ROUNDUP8(((ul)rpb_lurt) + sizeof(xxm_lurt));
+ rpb_dsr->rpb_sysname_off = ((ul) rpb_name) - (ul) rpb_dsr;
+#define THENAME " SimOS ALPHA/EV5"
+ sum = sizeof(THENAME);
+ bcopy(THENAME, rpb_name, sum);
+ *(ul *)rpb_name = sizeof(THENAME); /* put in length field */
+
+ /* calculate size of rpb */
+ rpb->rpb_size = ((ul) &rpb_name[sum]) - (ul)rpb;
+
+ if (rpb->rpb_size > 8192*HWRPB_PAGES) {
+ panic("HWRPB_PAGES=%d too small for HWRPB !!! \n");
+ }
+
+
+ {
+ ul *ptr = (ul*)((char*)rpb_dsr + sizeof(struct rpb_dsr ));
+ rpb_crb->rpb_pa_disp = KSEG_TO_PHYS(ptr);
+ rpb_crb->rpb_va_disp = 0x10000000 + ((ul)ptr&(0x2000*HWRPB_PAGES-1));
+ printf("ConsoleDispatch at virt %x phys %x val %x\n",
+ rpb_crb->rpb_va_disp,
+ rpb_crb->rpb_pa_disp,
+ consoleCallback);
+ *ptr++ = 0;
+ *ptr++ = (ul) consoleCallback;
+ rpb_crb->rpb_pa_fixup = KSEG_TO_PHYS(ptr);
+ rpb_crb->rpb_va_fixup = 0x10000000 + ((ul)ptr& (0x2000*HWRPB_PAGES-1));
+ *ptr++ = 0;
+ *ptr++ = (ul) 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
+ */
+
+ {
+ int i;
+ for (i=1;i<simosConf.numCPUs;i++) {
+ volatile AlphaAccess *k1Conf = (volatile AlphaAccess *)
+ (__MAGIC_ZONE(0, 0, MAGIC_ZONE_EV5_ALIAS));
+ SpinLock(&theLock);
+ printf("Bootstraping CPU %d with sp=0x%x \n",
+ i,bootStrapImpure[i]);
+ SpinUnlock(&theLock);
+ k1Conf->bootStrapImpure = bootStrapImpure[i];
+ k1Conf->bootStrapCPU = i;
+ }
+ }
+
+ /*
+ * Make sure that we are not stepping on the kernel
+ */
+ if ((ul)unix_boot_mem >= (ul)simosConf.kernStart) {
+ panic("CONSOLE: too much memory. Smashing kernel \n");
+ } else {
+ SpinLock(&theLock);
+ printf("unix_boot_mem ends at %x \n",unix_boot_mem);
+ SpinUnlock(&theLock);
+ }
+
+
+#ifdef undef
+#define CSERVE_K_JTOKERN 0x18
+ cServe(bootadr, (ul) rpb_percpu, CSERVE_K_JTOKERN, free_pfn);
+#endif
+
+ if (go) JToKern(bootadr, rpb_percpu, free_pfn, kargc, kargv, NULL);
+}
+
+
+#if 0
+aoutfixup(char *p)
+{
+ int i;
+ unsigned long rem, len, off, dst;
+
+
+ struct new_aouthdr *ao = (struct new_aouthdr *) &p[NEW_FILHSZ];
+#if 0
+ struct scnhdr *s = (struct scnhdr *) &p[FILHSZ + AOUTHSZ];
+ struct scnhdr *t, *d, *b;
+ printf("aoutfixup: %d sections \n",fh->f_nscns);
+#endif
+
+
+ aout_text_start = ((ul)ao->text_start_hi<<32) + ao->text_start;
+ aout_data_addr = ((ul)ao->data_start_hi<<32) + ao->data_start;
+ aout_bss_addr = ((ul)ao->bss_start_hi<<32) + ao->bss_start;
+ aout_bss_size = ((ul)ao->bsize_hi<<32) + ao->bsize;
+ aout_entry = ((ul)ao->entry_hi<<32) + ao->entry;
+
+ printf("_text 0x%16x %8d @ %08d\n", aout_text_start, ao->tsize,0 /* t->s_scnptr*/);
+ printf("_data 0x%16x %8d @ %08d\n", aout_data_addr, ao->dsize,0/* d->s_scnptr*/);
+ printf("_bss 0x%16x %8d\n", aout_bss_addr, ao->bsize);
+ printf("entry 0x%16x\n", aout_entry);
+#if 0
+ for (i = 0; i < fh->f_nscns; i++) {
+ printf("section %d %s \n",i,s[i].s_name);
+ if (!strcmp(s[i].s_name, ".text")) t = &s[i];
+ else if (!strcmp(s[i].s_name, ".data")) d = &s[i];
+ else if (!strcmp(s[i].s_name, ".bss")) b = &s[i];
+ }
+ bcopy(&p[t->s_scnptr], (char *)ao->text_start, ao->tsize);
+ bcopy(&p[d->s_scnptr], (char *)ao->data_start, ao->dsize);
+#endif
+}
+#endif
+
+extern ui palJToKern[];
+
+JToKern(bootadr, rpb_percpu, free_pfn, k_argc, k_argv, envp)
+char * bootadr;
+ul rpb_percpu;
+ul free_pfn;
+ul k_argc;
+char **k_argv;
+char **envp;
+{
+ struct _kernel_params *kernel_params = (struct _kernel_params *) KSEG;
+ int i;
+
+ printf("k_argc = %d ", k_argc);
+ for (i = 0; i < k_argc; i++) {
+ printf("'%s' ", k_argv[i]);
+ }
+ printf("\n");
+
+/* rpb_percpu |= 0xfffffc0000000000;*/
+ 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 = (ul)k_argv;
+ kernel_params->envp = (ul)envp;
+ printf("jumping to kernel at 0x%x, (PCBB 0x%x pfn %d)\n", bootadr, rpb_percpu, free_pfn);
+ jToPal(KSEG_TO_PHYS((ul)palJToKern));
+ printf("returned from jToPal. Looping\n");
+ while(1) continue;
+}
+
+
+void jToPal(ul 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"
+
+void DeviceOperation(long op,long channel, long count, long address, long block)
+{
+ AlphaAccess *k1Conf = (AlphaAccess *)
+ (__MAGIC_ZONE(0, 0, MAGIC_ZONE_EV5_ALIAS));
+
+ long pAddr;
+
+#if 0
+ printf("Console::DeviceRead count=0x%x address=0x%x block=0x%x\n",
+ count,address,block);
+#endif
+
+ if (strcmp(deviceState[channel].name, BOOTDEVICE_NAME )) {
+ panic("DeviceRead: only implemented for root disk \n");
+ }
+ pAddr = KSEG_TO_PHYS(address);
+ if (pAddr + count > simosConf.mem_size) {
+ panic("DeviceRead: request out of range \n");
+ }
+
+ k1Conf->diskCount = count;
+ k1Conf->diskPAddr = pAddr;
+ k1Conf->diskBlock = block;
+ k1Conf->diskOperation = op; /* launch */
+}
+
+
+
+/* *************************************************************************
+ * SimoS 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 0x10
+#define CONSCB_CLOSE 0x11
+#define CONSCB_READ 0x13
+
+#define CONSCB_GETENV 0x22
+
+/* AXP manual 2-26 */
+
+#define ENV_BOOTED_DEV 0x4
+#define ENV_BOOTED_OSFLAGS 0x8
+
+long CallBackDispatcher(long a0, long a1, long a2, long a3, long a4)
+{
+ int i;
+ switch (a0) {
+ case CONSCB_PUTS:
+ for(i=0;i<a3;i++) {
+ PutChar(*(char *)a2+i);
+ }
+ return a3;
+ case CONSCB_GETENV:
+ switch (a1) {
+ case ENV_BOOTED_DEV:
+ i = strcpy((char*)a2,BOOTDEVICE_NAME);
+ break;
+ case ENV_BOOTED_OSFLAGS:
+ /*
+ * 'c':ignores the sysconfigtab
+ *
+ * i= strcpy((char*)a2,"c");
+ */
+ i = strcpy((char*)a2,"");
+ break;
+ default:
+ i = strcpy((char*)a2,"");
+ printf ("GETENV unsupported option %d\n", a1);
+ break;
+ }
+ 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("CONSOLE OPEN : %s --> success \n",
+ deviceState[numOpenDevices].name);
+ return numOpenDevices++;
+
+ case CONSCB_READ:
+ DeviceOperation(a0,a1,a2,a3,a4);
+ break;
+ case CONSCB_CLOSE:
+ break;
+ default:
+ panic("cher (%x,%x,%x,%x) \n",
+ a0,a1,a2,a3);
+ }
+ return 0;
+}
+
+long CallBackFixup(int a0, int a1, int a2)
+{
+ printf("CallbackFixup %x %x \n",a0,a1);
+
+#if 0
+ if (first[FIRST(a1)]==0) {
+ first[FIRST(a1)] = KPTE(PFN(reservedFixup));
+ } else {
+ panic("CallBakcfixup\n");
+ }
+ second[SECOND(a1)] = KPTE(PFN(third_rpb)); /* Region 0 */
+ printf("Fixup: FISRT(a1)=0x%x SECOND(a1)=0x%x THIRD(a1)=0x%x\n",
+ FIRST(a1),SECOND(a1),THIRD(a1));
+
+#endif
+ return 0;
+}
+
+
+
+
+
+void SlaveCmd(int cpu, struct rpb_percpu *my_rpb)
+{
+/* extern void palJToSlave[]; */
+ extern unsigned int palJToSlave[];
+
+
+ my_rpb->rpb_state |= STATE_BIP;
+ my_rpb->rpb_state &= ~STATE_RC;
+
+ SpinLock(&theLock);
+ printf("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));
+ SpinUnlock(&theLock);
+
+ cServe(KSEG_TO_PHYS((ul)palJToSlave),
+ (ul)rpb->rpb_restart,
+ CSERVE_K_JTOPAL,
+ rpb->rpb_restart_pv,
+ rpb->rpb_vptb,
+ KSEG_TO_PHYS(my_rpb));
+}
+
+void SlaveLoop( int cpu)
+{
+ int size = ROUNDUP128(sizeof(struct rpb_percpu));
+ struct rpb_percpu *my_rpb = (struct rpb_percpu*)
+ ((ul)rpb_percpu + size*cpu);
+
+
+ SpinLock(&theLock);
+ if (cpu==0) {
+ panic("CPU 0 entering slaveLoop. Reenetering the console. HOSED \n");
+ } else {
+ printf("Entering slaveloop for cpu %d my_rpb=%x \n",cpu,my_rpb);
+ }
+ SpinUnlock(&theLock);
+ while(1) {
+ int i;
+ for (i=0; i < 1000000 ; i++) {
+ if (my_rpb->rpb_iccb.iccb_rxlen) {
+ SpinLock(&theLock);
+ printf("Slave CPU %d console command %s",
+ cpu,my_rpb->rpb_iccb.iccb_rxbuf);
+ SpinUnlock(&theLock);
+ SlaveCmd(cpu,my_rpb);
+ panic("SlaveCmd returned \n");
+ }
+ }
+ printf("*");
+ }
+}
+