5821f37cb6
I steped on while doing it
console/console.c:
Allocate more HWRPB pages so we have room for 64 percpu_rpbs
Fix writing of Console Relocation Block virtual addresses so that
if they are outside of the first page, which they will be with more
than 8 processors, the correct adress is written
palcode/Makefile:
Update makefile for tsunami with 64 processors
palcode/platform_m5.S:
Add support for tsunami with 64 processors
1278 lines
37 KiB
C
1278 lines
37 KiB
C
|
||
|
||
/* ******************************************
|
||
* 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)
|
||
|
||
#ifdef TSUNAMI
|
||
#define ALPHA_ACCESS_BASE 0xfffffd0200000000
|
||
#elif TLASER
|
||
#define ALPHA_ACCESS_BASE 0xfffffc8000a00000
|
||
#else
|
||
#error TSUNAMI/TLASER not defined.
|
||
#endif
|
||
|
||
#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 16
|
||
#define MDT_BITMAP_PAGES 4
|
||
|
||
#define CSERVE_K_JTOKERN 0x18
|
||
|
||
#define NUM_KERNEL_THIRD (4)
|
||
|
||
#define printf_lock(args...) \
|
||
do { \
|
||
SpinLock(&theLock); \
|
||
printf(args); \
|
||
SpinUnlock(&theLock); \
|
||
} while (0)
|
||
|
||
|
||
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_lock("M5 console\n");
|
||
/*
|
||
* get configuration from backdoor
|
||
*/
|
||
simosConf.last_offset = k1Conf->last_offset;
|
||
printf_lock("Got Configuration %d \n",simosConf.last_offset);
|
||
|
||
simosConf.last_offset = k1Conf->last_offset;
|
||
simosConf.version = k1Conf->version;
|
||
simosConf.numCPUs = k1Conf->numCPUs;
|
||
simosConf.intrClockFrequency = k1Conf->intrClockFrequency;
|
||
simosConf.cpuClock = k1Conf->cpuClock;
|
||
simosConf.mem_size = k1Conf->mem_size;
|
||
simosConf.kernStart = k1Conf->kernStart;
|
||
simosConf.kernEnd = k1Conf->kernEnd;
|
||
simosConf.entryPoint = k1Conf->entryPoint;
|
||
simosConf.diskUnit = k1Conf->diskUnit;
|
||
simosConf.diskCount = k1Conf->diskCount;
|
||
simosConf.diskPAddr = k1Conf->diskPAddr;
|
||
simosConf.diskBlock = k1Conf->diskBlock;
|
||
simosConf.diskOperation = k1Conf->diskOperation;
|
||
simosConf.outputChar = k1Conf->outputChar;
|
||
simosConf.inputChar = k1Conf->inputChar;
|
||
simosConf.bootStrapImpure = k1Conf->bootStrapImpure;
|
||
simosConf.bootStrapCPU = k1Conf->bootStrapCPU;
|
||
|
||
if (simosConf.version != ALPHA_ACCESS_VERSION) {
|
||
panic("Console version mismatch. Console expects %d. 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, /* OVERRIDDEN */
|
||
(1<<10), /* 058: system variation OVERRIDDEN */
|
||
'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,1,{0,0},{0,0,0,0,0,0,0,0}}, /* 000: boot/restart HWPCB */
|
||
(STATE_PA | STATE_PP | STATE_CV | STATE_PV | STATE_PMV | STATE_PL), /* 080: per-cpu state bits */
|
||
0xc000, /* 088: palcode memory length */
|
||
0x2000, /* 090: palcode scratch length */
|
||
0x4000, /* 098: phys addr of palcode mem space */
|
||
0x2000, /* 0A0: phys addr of palcode scratch space */
|
||
(2 << 16) | (5 << 8) | 1, /* 0A8: PALcode rev required */
|
||
11 | (2L << 32), /* 0B0: processor type */
|
||
7, /* 0B8: processor variation */
|
||
'M'|('5'<<8)|('A'<<16)|('0'<<24), /* 0C0: processor revision */
|
||
{'M','5','/','A','l','p','h','a','0','0','0','0','0','0','0','0'}, /* 0C8: proc serial num: 10 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_lock( "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_lock("First free page after ROM 0x%x\n", unix_boot_mem);
|
||
|
||
rpb = (struct rpb *) unix_boot_alloc( HWRPB_PAGES);
|
||
|
||
mdt_bitmap = (unsigned char *) unix_boot_alloc(MDT_BITMAP_PAGES);
|
||
first = (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_lock("HWRPB 0x%x l1pt 0x%x l2pt 0x%x l3pt_rpb 0x%x l3pt_kernel 0x%x l2reserv 0x%x\n",
|
||
rpb, first, second, third_rpb, third_kernel,reservedFixup);
|
||
if (kernel_end - simosConf.kernStart > (0x800000*NUM_KERNEL_THIRD)) {
|
||
printf_lock("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_lock("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_lock("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_lock("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_lock("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 = KSEG_TO_PHYS(((ul)rpb) & ~0x1fff);
|
||
rpb_crb->rpb_map[0].rpb_pgcount = HWRPB_PAGES;
|
||
|
||
|
||
printf_lock("Console Callback at 0x%x, fixup at 0x%x, crb offset: 0x%x\n",
|
||
rpb_crb->rpb_va_disp,
|
||
rpb_crb->rpb_va_fixup,
|
||
rpb->rpb_crb_off);
|
||
|
||
rpb_mdt = (struct _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_lock("Memory cluster %d [%d - %d]\n", i, rpb_mdt->rpb_cluster[i].rpb_pfn, rpb_mdt->rpb_cluster[i].rpb_pfncount);
|
||
|
||
|
||
|
||
/* Checksum the rpb for good luck */
|
||
sum = 0;
|
||
lp1 = (long *)&rpb_mdt->rpb_impaddr;
|
||
lp2 = (long *)&rpb_mdt->rpb_cluster[cl];
|
||
while (lp1 < lp2) sum += *lp1++;
|
||
rpb_mdt->rpb_checksum = sum;
|
||
|
||
/* XXX should checksum the cluster descriptors */
|
||
|
||
bzero((char *)mdt_bitmap, MDT_BITMAP_PAGES * 8192);
|
||
for (i = 0; i < mem_pages/8; i++) ((unsigned char *)mdt_bitmap)[i] = 0xff;
|
||
|
||
printf_lock("Initalizing mdt_bitmap addr 0x%x mem_pages %x \n",
|
||
(long)mdt_bitmap,(long)mem_pages);
|
||
|
||
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 " M5/Alpha "
|
||
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 - (ul)rpb) & (0x2000*HWRPB_PAGES-1));
|
||
printf_lock("ConsoleDispatch at virt %x phys %x val %x\n",
|
||
rpb_crb->rpb_va_disp,
|
||
rpb_crb->rpb_pa_disp,
|
||
consoleCallback);
|
||
*ptr++ = 0;
|
||
*ptr++ = (ul) consoleCallback;
|
||
rpb_crb->rpb_pa_fixup = KSEG_TO_PHYS(ptr);
|
||
rpb_crb->rpb_va_fixup = 0x10000000 + (((ul)ptr - (ul)rpb) & (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 struct AlphaAccess *k1Conf = (volatile struct AlphaAccess *)
|
||
(ALPHA_ACCESS_BASE);
|
||
printf_lock("Bootstraping CPU %d with sp=0x%x \n",
|
||
i,bootStrapImpure[i]);
|
||
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 {
|
||
printf_lock("unix_boot_mem ends at %x \n",unix_boot_mem);
|
||
}
|
||
|
||
|
||
#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_lock("k_argc = %d ", k_argc);
|
||
for (i = 0; i < k_argc; i++) {
|
||
printf_lock("'%s' ", k_argv[i]);
|
||
}
|
||
printf_lock("\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_lock("jumping to kernel at 0x%x, (PCBB 0x%x pfn %d)\n", bootadr, rpb_percpu, free_pfn);
|
||
jToPal(KSEG_TO_PHYS((ul)palJToKern));
|
||
printf_lock("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_lock("GETENV unsupported option %d (0x%x)\n", a1, a1);
|
||
else
|
||
printf_lock("GETENV unsupported option %s\n", a1);
|
||
}
|
||
|
||
if (i > a3)
|
||
panic("CONSCB_GETENV overwrote buffer\n");
|
||
return i;
|
||
|
||
case CONSCB_OPEN:
|
||
bcopy((char*)a1,deviceState[numOpenDevices].name,a2);
|
||
deviceState[numOpenDevices].name[a2] = '\0';
|
||
printf_lock("CONSOLE OPEN : %s --> success \n",
|
||
deviceState[numOpenDevices].name);
|
||
return numOpenDevices++;
|
||
|
||
case CONSCB_READ:
|
||
DeviceOperation(a0,a1,a2,a3,a4);
|
||
break;
|
||
|
||
case CONSCB_CLOSE:
|
||
break;
|
||
case CONSCB_OPEN_CONSOLE:
|
||
printf_lock("CONSOLE OPEN\n");
|
||
return 0; /* success */
|
||
break; /* not rearched */
|
||
case CONSCB_CLOSE_CONSOLE:
|
||
printf_lock("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_lock("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[];
|
||
|
||
printf_lock("Slave CPU %d console command %s", cpu,my_rpb->rpb_iccb.iccb_rxbuf);
|
||
|
||
my_rpb->rpb_state |= STATE_BIP;
|
||
my_rpb->rpb_state &= ~STATE_RC;
|
||
|
||
printf_lock("SlaveCmd: restart %x %x vptb %x my_rpb %x my_rpb_phys %x\n",
|
||
rpb->rpb_restart,
|
||
rpb->rpb_restart_pv,
|
||
rpb->rpb_vptb, my_rpb,
|
||
KSEG_TO_PHYS(my_rpb));
|
||
|
||
cServe(KSEG_TO_PHYS((ul)palJToSlave),
|
||
(ul)rpb->rpb_restart,
|
||
CSERVE_K_JTOPAL,
|
||
rpb->rpb_restart_pv,
|
||
rpb->rpb_vptb,
|
||
KSEG_TO_PHYS(my_rpb));
|
||
|
||
panic("SlaveCmd returned \n");
|
||
}
|
||
|
||
void SlaveLoop( int cpu)
|
||
{
|
||
int size = ROUNDUP128(sizeof(struct rpb_percpu));
|
||
struct rpb_percpu *my_rpb = (struct rpb_percpu*)
|
||
((ul)rpb_percpu + size*cpu);
|
||
|
||
if (cpu==0) {
|
||
panic("CPU 0 entering slaveLoop. Reenetering the console. HOSED \n");
|
||
} else {
|
||
printf_lock("Entering slaveloop for cpu %d my_rpb=%x \n",cpu,my_rpb);
|
||
}
|
||
|
||
// swap the processors context to the one in the
|
||
// rpb_percpu struct very carefully (i.e. no stack usage)
|
||
// so that linux knows which processor ends up in __smp_callin
|
||
// and we don't trash any data is the process
|
||
SlaveSpin(cpu,my_rpb,&my_rpb->rpb_iccb.iccb_rxlen);
|
||
}
|