/* ****************************************** * SimOS SRM Console * * Derived from Lance Berc's SRM console * for the SRC XXM Machine * ******************************************/ typedef unsigned long long uint64_t; typedef unsigned long long uint64; typedef unsigned int uint32_t; typedef unsigned int uint32; #define CONSOLE #include "alpha_access.h" #if 0 #include "new_aouthdr.h" #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 ALPHA_ACCESS_BASE 0xfffffc8000a00000 #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); struct 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 } char GetChar() { struct AlphaAccess *k1Conf = (struct AlphaAccess *)(ALPHA_ACCESS_BASE); return k1Conf->inputChar; } void PutChar(char c) { #if 0 CDR->data = c; #endif #if 0 *(int*) PHYS_TO_K1(SLOT_D_COM1<<5) = c; #endif struct AlphaAccess *k1Conf = (struct AlphaAccess *)(ALPHA_ACCESS_BASE); k1Conf->outputChar = c; } int passArgs(int argc) { return 0; } int main(int argc, char **argv) { int x,i; struct AlphaAccess *k1Conf = (struct AlphaAccess *)(ALPHA_ACCESS_BASE); 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 */ ((long)'H') | (((long)'W') << 8) | (((long)'R') << 16) | ((long)'P' << 24) | (((long)'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 0, /* masquerade a Tsunami RGD */ (1<<10), /* 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 | (2L << 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; int strcpy(char *dst, char *src); 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 (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;irpb_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); #if 0 rpb_crb->rpb_va_disp = 0x10000000 + ((ul)ptr&(0x2000*HWRPB_PAGES-1)); #else rpb_crb->rpb_va_disp = 0x10000000 + ((ul)ptr & 0x1fff); #endif 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); #if 0 rpb_crb->rpb_va_fixup = 0x10000000 + ((ul)ptr& (0x2000*HWRPB_PAGES-1)); #else rpb_crb->rpb_va_fixup = 0x10000000 + ((ul)ptr & 0x1fff); #endif *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;ibootStrapImpure = 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 0" void DeviceOperation(long op, long channel, long count, long address, long block) { struct AlphaAccess *k1Conf = (struct AlphaAccess *) (ALPHA_ACCESS_BASE); 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_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 *env_ptr[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 && env_ptr[a1] != 0 && *env_ptr[a1]) { i = strcpy((char*)a2, env_ptr[a1]); } else { strcpy((char*)a2, ""); i = (long)0xc000000000000000; if (a1 >= 0 && a1 < MAX_ENV_INDEX) printf ("GETENV unsupported option %d (0x%x)\n", a1, a1); else printf ("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("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("CONSOLE OPEN\n"); return 0; /* success */ break; /* not rearched */ case CONSCB_CLOSE_CONSOLE: printf("CONSOLE CLOSE\n"); return 0; /* success */ break; /* not reached */ default: panic("cher (%x,%x,%x,%x)\n", a0, a1, a2, a3); } 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 could 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("CallbackFixup %x %x, t7=%x\n",a0,a1,temp); /* restore the current pointer */ asm("bis %0, $31, $8" : : "r" (temp) : "$8"); #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("*"); } }