diff options
Diffstat (limited to 'system/alpha/console/console.c')
| -rw-r--r-- | system/alpha/console/console.c | 1126 |
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("*"); + } +} + |