1/* 2 * Copyright (c) 2003-2004 The Regents of The University of Michigan 3 * Copyright (c) 1993 The Hewlett-Packard Development Company 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are 8 * met: redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer; 10 * redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution; 13 * neither the name of the copyright holders nor the names of its 14 * contributors may be used to endorse or promote products derived from 15 * this software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 */ 29 30/* ****************************************** 31 * M5 Console 32 * ******************************************/ 33 34#include <linux/stddef.h> 35#include <sys/types.h> 36 37#define CONSOLE 38#include "access.h" 39#include "cserve.h" 40#include "rpb.h" 41 42#define CONS_INT_TX 0x01 /* interrupt enable / state bits */ 43#define CONS_INT_RX 0x02 44 45#define PAGE_SIZE (8192) 46 47#define KSTACK_REGION_VA 0x20040000 48 49#define KSEG 0xfffffc0000000000 50#define K1BASE 0xfffffc8000000000 51#define KSEG_TO_PHYS(x) (((ulong)x) & ~KSEG) 52 53#define ROUNDUP8(x) ((ulong)(((ulong)x)+7) & ~7) 54#define ROUNDUP128(x) ((ulong)(((ulong)x) + 127) & ~127) 55#define ROUNDUP8K(x) ((ulong)(((ulong)(x)) + 8191) & ~8191) 56 57#define FIRST(x) ((((ulong)(x)) >> 33) & 0x3ff) 58#define SECOND(x) ((((ulong)(x)) >> 23) & 0x3ff) 59#define THIRD(x) ((((ulong)(x)) >> 13) & 0x3ff) 60#define THIRD_XXX(x) ((((ulong)(x)) >> 13) & 0xfff) 61#define PFN(x) ((((ulong)(x) & ~KSEG) >> 13)) 62 63/* Kernel write | kernel read | valid */ 64#define KPTE(x) ((ulong)((((ulong)(x)) << 32) | 0x1101)) 65 66#define HWRPB_PAGES 16 67 68#define NUM_KERNEL_THIRD (4) 69 70#define printf_lock(args...) \ 71 do { \ 72 SpinLock(&theLock); \ 73 printf(args); \ 74 SpinUnlock(&theLock); \ 75 } while (0) 76 77 78void unixBoot(int argc, char **argv); 79void JToKern(char *bootadr, ulong rpb_percpu, ulong free_pfn, ulong k_argc, 80 char **k_argv, char **envp); 81void JToPal(ulong bootadr); 82void SlaveLoop(int cpu); 83 84volatile struct AlphaAccess *m5AlphaAccess; 85struct AlphaAccess m5Conf; 86 87ulong theLock; 88 89extern void SpinLock(ulong *lock); 90#define SpinUnlock(_x) *(_x) = 0; 91 92struct _kernel_params { 93 char *bootadr; 94 ulong rpb_percpu; 95 ulong free_pfn; 96 ulong argc; 97 ulong argv; 98 ulong envp; /* NULL */ 99}; 100 101extern consoleCallback[]; 102extern consoleFixup[]; 103long CallBackDispatcher(); 104long CallBackFixup(); 105 106/* 107 * m5 console output 108 */ 109 110void 111InitConsole() 112{ 113} 114 115char 116GetChar() 117{ 118 return m5AlphaAccess->inputChar; 119} 120 121void 122PutChar(char c) 123{ 124 m5AlphaAccess->outputChar = c; 125} 126 127int 128passArgs(int argc) 129{ 130 return 0; 131} 132 133int 134main(int argc, char **argv) 135{ 136 int x, i; 137 uint *k1ptr, *ksegptr; 138 139 InitConsole(); 140 printf_lock("M5 console: m5AlphaAccess @ 0x%x\n", m5AlphaAccess); 141 142 /* 143 * get configuration from backdoor 144 */ 145 m5Conf.last_offset = m5AlphaAccess->last_offset; 146 printf_lock("Got Configuration %d\n", m5Conf.last_offset); 147 148 m5Conf.last_offset = m5AlphaAccess->last_offset; 149 m5Conf.version = m5AlphaAccess->version; 150 m5Conf.numCPUs = m5AlphaAccess->numCPUs; 151 m5Conf.intrClockFrequency = m5AlphaAccess->intrClockFrequency; 152 m5Conf.cpuClock = m5AlphaAccess->cpuClock; 153 m5Conf.mem_size = m5AlphaAccess->mem_size; 154 m5Conf.kernStart = m5AlphaAccess->kernStart; 155 m5Conf.kernEnd = m5AlphaAccess->kernEnd; 156 m5Conf.entryPoint = m5AlphaAccess->entryPoint; 157 m5Conf.diskUnit = m5AlphaAccess->diskUnit; 158 m5Conf.diskCount = m5AlphaAccess->diskCount; 159 m5Conf.diskPAddr = m5AlphaAccess->diskPAddr; 160 m5Conf.diskBlock = m5AlphaAccess->diskBlock; 161 m5Conf.diskOperation = m5AlphaAccess->diskOperation; 162 m5Conf.outputChar = m5AlphaAccess->outputChar; 163 m5Conf.inputChar = m5AlphaAccess->inputChar; 164 165 if (m5Conf.version != ALPHA_ACCESS_VERSION) { 166 panic("Console version mismatch. Console expects %d. has %d \n", 167 ALPHA_ACCESS_VERSION, m5Conf.version); 168 } 169 170 /* 171 * setup arguments to kernel 172 */ 173 unixBoot(argc, argv); 174 175 panic("unix failed to boot\n"); 176 return 1; 177} 178 179/* 180 * BOOTING 181 */ 182struct rpb m5_rpb = { 183 NULL, /* 000: physical self-reference */ 184 ((long)'H') | (((long)'W') << 8) | (((long)'R') << 16) | 185 ((long)'P' << 24) | (((long)'B') << 32), /* 008: contains "HWRPB" */ 186 6, /* 010: HWRPB version number */ 187 /* the byte count is wrong, but who needs it? - lance */ 188 0, /* 018: bytes in RPB perCPU CTB CRB MEDSC */ 189 0, /* 020: primary cpu id */ 190 PAGE_SIZE, /* 028: page size in bytes */ 191 43, /* 030: number of phys addr bits */ 192 127, /* 038: max valid ASN */ 193 {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','1'}, 194 /* 040: system serial num: 10 ascii chars */ 195 0, /* OVERRIDDEN */ 196 (1<<10), /* 058: system variation */ 197 'c'|('o'<<8)|('o'<<16)|('l'<< 24), /* 060: system revision */ 198 1024*4096, /* 068: scaled interval clock intr freq */ 199 0, /* 070: cycle counter frequency */ 200 0x200000000, /* 078: virtual page table base */ 201 0, /* 080: reserved */ 202 0, /* 088: offset to translation buffer hint */ 203 1, /* 090: number of processor slots OVERRIDDEN*/ 204 sizeof(struct rpb_percpu), /* 098: per-cpu slot size. OVERRIDDEN */ 205 0, /* 0A0: offset to per_cpu slots */ 206 1, /* 0A8: number of CTBs */ 207 sizeof(struct ctb_tt), 208 0, /* 0B8: offset to CTB (cons term block) */ 209 0, /* 0C0: offset to CRB (cons routine block) */ 210 0, /* 0C8: offset to memory descriptor table */ 211 0, /* 0D0: offset to config data block */ 212 0, /* 0D8: offset to FRU table */ 213 0, /* 0E0: virt addr of save term routine */ 214 0, /* 0E8: proc value for save term routine */ 215 0, /* 0F0: virt addr of restore term routine */ 216 0, /* 0F8: proc value for restore term routine */ 217 0, /* 100: virt addr of CPU restart routine */ 218 0, /* 108: proc value for CPU restart routine */ 219 0, /* 110: used to determine presence of kdebug */ 220 0, /* 118: reserved for hardware */ 221/* the checksum is wrong, but who needs it? - lance */ 222 0, /* 120: checksum of prior entries in rpb */ 223 0, /* 128: receive ready bitmask */ 224 0, /* 130: transmit ready bitmask */ 225 0, /* 138: Dynamic System Recog. offset */ 226}; 227 228ulong m5_tbb[] = { 0x1e1e1e1e1e1e1e1e, 0x1e1e1e1e1e1e1e1e, 229 0x1e1e1e1e1e1e1e1e, 0x1e1e1e1e1e1e1e1e, 230 0x1e1e1e1e1e1e1e1e, 0x1e1e1e1e1e1e1e1e, 231 0x1e1e1e1e1e1e1e1e, 0x1e1e1e1e1e1e1e1e }; 232 233struct rpb_percpu m5_rpb_percpu = { 234 {0,0,0,0,0,0,1,{0,0},{0,0,0,0,0,0,0,0}}, /* 000: boot/restart HWPCB */ 235 (STATE_PA | STATE_PP | STATE_CV | 236 STATE_PV | STATE_PMV | STATE_PL), /* 080: per-cpu state bits */ 237 0xc000, /* 088: palcode memory length */ 238 0x2000, /* 090: palcode scratch length */ 239 0x4000, /* 098: paddr of pal mem space */ 240 0x2000, /* 0A0: paddr of pal scratch space */ 241 (2 << 16) | (5 << 8) | 1, /* 0A8: PALcode rev required */ 242 11 | (2L << 32), /* 0B0: processor type */ 243 7, /* 0B8: processor variation */ 244 'M'|('5'<<8)|('A'<<16)|('0'<<24), /* 0C0: processor revision */ 245 {'M','5','/','A','l','p','h','a','0','0','0','0','0','0','0','0'}, 246 /* 0C8: proc serial num: 10 chars */ 247 0, /* 0D8: phys addr of logout area */ 248 0, /* 0E0: len in bytes of logout area */ 249 0, /* 0E8: halt pcb base */ 250 0, /* 0F0: halt pc */ 251 0, /* 0F8: halt ps */ 252 0, /* 100: halt arg list (R25) */ 253 0, /* 108: halt return address (R26) */ 254 0, /* 110: halt procedure value (R27) */ 255 0, /* 118: reason for halt */ 256 0, /* 120: for software */ 257 {0}, /* 128: inter-console comm buffer */ 258 {1,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0}, /* 1D0: PALcode revs available */ 259 0 /* 250: reserved for arch use */ 260/* the dump stack grows from the end of the rpb page not to reach here */ 261}; 262 263struct _m5_rpb_mdt { 264 long rpb_checksum; /* 000: checksum of entire mem desc table */ 265 long rpb_impaddr; /* 008: PA of implementation dep info */ 266 long rpb_numcl; /* 010: number of clusters */ 267 struct rpb_cluster rpb_cluster[3]; /* first instance of a cluster */ 268}; 269 270struct _m5_rpb_mdt m5_rpb_mdt = { 271 0, /* 000: checksum of entire mem desc table */ 272 0, /* 008: PA of implementation dep info */ 273 0, /* 010: number of clusters */ 274 {{ 0, /* 000: starting PFN of this cluster */ 275 0, /* 008: count of PFNs in this cluster */ 276 0, /* 010: count of tested PFNs in cluster */ 277 0, /* 018: va of bitmap */ 278 0, /* 020: pa of bitmap */ 279 0, /* 028: checksum of bitmap */ 280 1 /* 030: usage of cluster */ 281 }, 282 { 0, /* 000: starting PFN of this cluster */ 283 0, /* 008: count of PFNs in this cluster */ 284 0, /* 010: count of tested PFNs in cluster */ 285 0, /* 018: va of bitmap */ 286 0, /* 020: pa of bitmap */ 287 0, /* 028: checksum of bitmap */ 288 0 /* 030: usage of cluster */ 289 }, 290 { 0, /* 000: starting PFN of this cluster */ 291 0, /* 008: count of PFNs in this cluster */ 292 0, /* 010: count of tested PFNs in cluster */ 293 0, /* 018: va of bitmap */ 294 0, /* 020: pa of bitmap */ 295 0, /* 028: checksum of bitmap */ 296 0 /* 030: usage of cluster */ 297 }} 298}; 299 300/* constants for slotinfo bus_type subfield */ 301#define SLOTINFO_TC 0 302#define SLOTINFO_ISA 1 303#define SLOTINFO_EISA 2 304#define SLOTINFO_PCI 3 305 306struct rpb_ctb m5_rpb_ctb = { 307 CONS_DZ, /* 000: console type */ 308 0, /* 008: console unit */ 309 0, /* 010: reserved */ 310 0 /* 018: byte length of device dep portion */ 311}; 312 313/* we don't do any fixup (aka relocate the console) - we hope */ 314struct rpb_crb m5_rpb_crb = { 315 0, /* va of call-back dispatch rtn */ 316 0, /* pa of call-back dispatch rtn */ 317 0, /* va of call-back fixup rtn */ 318 0, /* pa of call-back fixup rtn */ 319 0, /* number of entries in phys/virt map */ 320 0 /* Number of pages to be mapped */ 321}; 322 323struct _rpb_name { 324 ulong length; 325 char name[16]; 326}; 327 328extern struct _rpb_name m5_name; 329 330struct rpb_dsr m5_rpb_dsr = { 331 0, 332 0, 333 0, 334}; 335 336struct _rpb_name m5_name = { 337 16, 338 {'U','M','I','C','H',' ','M','5','/','A','L','P','H','A',' ',0}, 339}; 340 341/* 342 * M5 has one LURT entry: 343 * 1050 is for workstations 344 * 1100 is servers (and is needed for CXX) 345 */ 346long m5_lurt[10] = { 9, 12, -1, -1, -1, -1, -1, -1, 1100, 1100 }; 347 348ulong unix_boot_mem; 349ulong bootadr; 350 351char **kargv; 352int kargc; 353ulong free_pfn; 354struct rpb_percpu *rpb_percpu; 355 356char * 357unix_boot_alloc(int pages) 358{ 359 char *ret = (char *)unix_boot_mem; 360 unix_boot_mem += (pages * PAGE_SIZE); 361 return ret; 362} 363 364ulong *first = 0; 365ulong *third_rpb = 0; 366ulong *reservedFixup = 0; 367 368int strcpy(char *dst, char *src); 369 370struct rpb *rpb; 371extern ulong _end; 372 373void 374unixBoot(int argc, char **argv) 375{ 376 ulong *second, *third_kernel, ptr, *tbb, size, *percpu_logout; 377 unsigned char *mdt_bitmap; 378 long *lp1, *lp2, sum; 379 int i, cl; 380 ulong kern_first_page; 381 ulong mem_size = m5Conf.mem_size; 382 383 ulong mem_pages = mem_size / PAGE_SIZE, cons_pages; 384 ulong mdt_bitmap_pages = mem_pages / (PAGE_SIZE*8); 385 386 ulong kernel_bytes, ksp, kernel_end, *unix_kernel_stack, bss, 387 ksp_bottom, ksp_top; 388 struct rpb_ctb *rpb_ctb; 389 struct ctb_tt *ctb_tt; 390 struct rpb_dsr *rpb_dsr; 391 struct rpb_crb *rpb_crb; 392 struct _m5_rpb_mdt *rpb_mdt; 393 int *rpb_lurt; 394 char *rpb_name; 395 ulong nextPtr; 396 397 printf_lock("memsize %x pages %x \n", mem_size, mem_pages); 398 399 /* Allocate: 400 * two pages for the HWRPB 401 * five page table pages: 402 * 1: First level page table 403 * 1: Second level page table 404 * 1: Third level page table for HWRPB 405 * 2: Third level page table for kernel (for up to 16MB) 406 * set up the page tables 407 * load the kernel at the physical address 0x230000 408 * build the HWRPB 409 * set up memory descriptor table to give up the 410 * physical memory between the end of the page 411 * tables and the start of the kernel 412 * enable kseg addressing 413 * jump to the kernel 414 */ 415 416 unix_boot_mem = ROUNDUP8K(&_end); 417 418 printf_lock("First free page after ROM 0x%x\n", unix_boot_mem); 419 420 rpb = (struct rpb *)unix_boot_alloc(HWRPB_PAGES); 421 422 mdt_bitmap = (unsigned char *)unix_boot_alloc(mdt_bitmap_pages); 423 first = (ulong *)unix_boot_alloc(1); 424 second = (ulong *)unix_boot_alloc(1); 425 third_rpb = (ulong *)unix_boot_alloc(1); 426 reservedFixup = (ulong*) unix_boot_alloc(1); 427 third_kernel = (ulong *)unix_boot_alloc(NUM_KERNEL_THIRD); 428 percpu_logout = (ulong*)unix_boot_alloc(1); 429 430 cons_pages = KSEG_TO_PHYS(unix_boot_mem) / PAGE_SIZE; 431 432 /* Set up the page tables */ 433 bzero((char *)first, PAGE_SIZE); 434 bzero((char *)second, PAGE_SIZE); 435 bzero((char *)reservedFixup, PAGE_SIZE); 436 bzero((char *)third_rpb, HWRPB_PAGES * PAGE_SIZE); 437 bzero((char *)third_kernel, PAGE_SIZE * NUM_KERNEL_THIRD); 438 439 first[0] = KPTE(PFN(second)); 440 first[1] = KPTE(PFN(first)); /* Region 3 */ 441 442 /* Region 0 */ 443 second[SECOND(0x10000000)] = KPTE(PFN(third_rpb)); 444 445 for (i = 0; i < NUM_KERNEL_THIRD; i++) { 446 /* Region 1 */ 447 second[SECOND(0x20000000) + i] = KPTE(PFN(third_kernel) + i); 448 } 449 450 /* Region 2 */ 451 second[SECOND(0x40000000)] = KPTE(PFN(second)); 452 453 454 /* For some obscure reason, Dec Unix's database read 455 * from /etc/sysconfigtab is written to this fixed 456 * mapped memory location. Go figure, since it is 457 * not initialized by the console. Maybe it is 458 * to look at the database from the console 459 * after a boot/crash. 460 * 461 * Black magic to estimate the max size. SEGVs on overflow 462 * bugnion 463 */ 464 465#define DATABASE_BASE 0x20000000 466#define DATABASE_END 0x20020000 467 468 ulong *dbPage = (ulong*)unix_boot_alloc(1); 469 bzero(dbPage, PAGE_SIZE); 470 second[SECOND(DATABASE_BASE)] = KPTE(PFN(dbPage)); 471 for (i = DATABASE_BASE; i < DATABASE_END ; i += PAGE_SIZE) { 472 ulong *db = (ulong*)unix_boot_alloc(1); 473 dbPage[THIRD(i)] = KPTE(PFN(db)); 474 } 475 476 /* Region 0 */ 477 /* Map the HWRPB */ 478 for (i = 0; i < HWRPB_PAGES; i++) 479 third_rpb[i] = KPTE(PFN(rpb) + i); 480 481 /* Map the MDT bitmap table */ 482 for (i = 0; i < mdt_bitmap_pages; i++) { 483 third_rpb[HWRPB_PAGES + i] = KPTE(PFN(mdt_bitmap) + i); 484 } 485 486 /* Protect the PAL pages */ 487 for (i = 1; i < PFN(first); i++) 488 third_rpb[HWRPB_PAGES + mdt_bitmap_pages + i] = KPTE(i); 489 490 /* Set up third_kernel after it's loaded, when we know where it is */ 491 kern_first_page = (KSEG_TO_PHYS(m5Conf.kernStart)/PAGE_SIZE); 492 kernel_end = ROUNDUP8K(m5Conf.kernEnd); 493 bootadr = m5Conf.entryPoint; 494 495 printf_lock("HWRPB 0x%x l1pt 0x%x l2pt 0x%x l3pt_rpb 0x%x l3pt_kernel 0x%x" 496 " l2reserv 0x%x\n", 497 rpb, first, second, third_rpb, third_kernel, reservedFixup); 498 if (kernel_end - m5Conf.kernStart > (0x800000*NUM_KERNEL_THIRD)) { 499 printf_lock("Kernel is more than 8MB 0x%x - 0x%x = 0x%x\n", 500 kernel_end, m5Conf.kernStart, 501 kernel_end - m5Conf.kernStart ); 502 panic("kernel too big\n"); 503 } 504 printf_lock("kstart = 0x%x, kend = 0x%x, kentry = 0x%x, numCPUs = 0x%x\n", m5Conf.kernStart, m5Conf.kernEnd, m5Conf.entryPoint, m5Conf.numCPUs); 505 ksp_bottom = (ulong)unix_boot_alloc(1); 506 ksp_top = ksp_bottom + PAGE_SIZE; 507 ptr = (ulong) ksp_bottom; 508 bzero((char *)ptr, PAGE_SIZE); 509 dbPage[THIRD(KSTACK_REGION_VA)] = 0; /* Stack Guard Page */ 510 dbPage[THIRD(KSTACK_REGION_VA + PAGE_SIZE)] = KPTE(PFN(ptr)); /* Kernel Stack Page */ 511 dbPage[THIRD(KSTACK_REGION_VA + 2*PAGE_SIZE)] = 0; /* Stack Guard Page */ 512 513 /* put argv into the bottom of the stack - argv starts at 1 because 514 * the command thatr got us here (i.e. "unixboot) is in argv[0]. 515 */ 516 ksp = ksp_top - 8; /* Back up one longword */ 517 ksp -= argc * sizeof(char *); /* Make room for argv */ 518 kargv = (char **) ksp; 519 for (i = 1; i < argc; i++) { /* Copy arguments to stack */ 520 ksp -= ((strlen(argv[i]) + 1) + 7) & ~0x7; 521 kargv[i-1] = (char *) ksp; 522 strcpy(kargv[i - 1], argv[i]); 523 } 524 kargc = i - 1; 525 kargv[kargc] = NULL; /* just to be sure; doesn't seem to be used */ 526 ksp -= sizeof(char *); /* point above last arg for no real reason */ 527 528 free_pfn = PFN(kernel_end); 529 530 bcopy((char *)&m5_rpb, (char *)rpb, sizeof(struct rpb)); 531 532 rpb->rpb_selfref = (struct rpb *) KSEG_TO_PHYS(rpb); 533 rpb->rpb_string = 0x0000004250525748; 534 535 tbb = (ulong *) (((char *) rpb) + ROUNDUP8(sizeof(struct rpb))); 536 rpb->rpb_trans_off = (ulong)tbb - (ulong)rpb; 537 bcopy((char *)m5_tbb, (char *)tbb, sizeof(m5_tbb)); 538 539 /* 540 * rpb_counter. Use to determine timeouts in OS. 541 * XXX must be patched after a checkpoint restore (I guess) 542 */ 543 544 printf_lock("CPU Clock at %d MHz IntrClockFrequency=%d \n", 545 m5Conf.cpuClock, m5Conf.intrClockFrequency); 546 rpb->rpb_counter = m5Conf.cpuClock * 1000 * 1000; 547 548 /* 549 * By definition, the rpb_clock is scaled by 4096 (in hz) 550 */ 551 rpb->rpb_clock = m5Conf.intrClockFrequency * 4096; 552 553 /* 554 * Per CPU Slots. Multiprocessor support. 555 */ 556 int percpu_size = ROUNDUP128(sizeof(struct rpb_percpu)); 557 558 printf_lock("Booting with %d processor(s) \n", m5Conf.numCPUs); 559 560 rpb->rpb_numprocs = m5Conf.numCPUs; 561 rpb->rpb_slotsize = percpu_size; 562 rpb_percpu = (struct rpb_percpu *) 563 ROUNDUP128(((ulong)tbb) + (sizeof(m5_tbb))); 564 565 rpb->rpb_percpu_off = (ulong)rpb_percpu - (ulong)rpb; 566 567 for (i = 0; i < m5Conf.numCPUs; i++) { 568 struct rpb_percpu *thisCPU = (struct rpb_percpu*) 569 ((ulong)rpb_percpu + percpu_size * i); 570 571 bzero((char *)thisCPU, percpu_size); 572 bcopy((char *)&m5_rpb_percpu, (char *)thisCPU, 573 sizeof(struct rpb_percpu)); 574 575 thisCPU->rpb_pcb.rpb_ksp = (KSTACK_REGION_VA + 2*PAGE_SIZE - (ksp_top - ksp)); 576 thisCPU->rpb_pcb.rpb_ptbr = PFN(first); 577 578 thisCPU->rpb_logout = KSEG_TO_PHYS(percpu_logout); 579 thisCPU->rpb_logout_len = PAGE_SIZE; 580 581 printf_lock("KSP: 0x%x PTBR 0x%x\n", 582 thisCPU->rpb_pcb.rpb_ksp, thisCPU->rpb_pcb.rpb_ptbr); 583 } 584 585 nextPtr = (ulong)rpb_percpu + percpu_size * m5Conf.numCPUs; 586 587 /* 588 * Console Terminal Block 589 */ 590 rpb_ctb = (struct rpb_ctb *) nextPtr; 591 ctb_tt = (struct ctb_tt*) rpb_ctb; 592 593 rpb->rpb_ctb_off = ((ulong)rpb_ctb) - (ulong)rpb; 594 rpb->rpb_ctb_size = sizeof(struct rpb_ctb); 595 596 bzero((char *)rpb_ctb, sizeof(struct ctb_tt)); 597 598 rpb_ctb->rpb_type = CONS_DZ; 599 rpb_ctb->rpb_length = sizeof(ctb_tt) - sizeof(rpb_ctb); 600 601 /* 602 * uart initizliation 603 */ 604 ctb_tt->ctb_tintr_vec = 0x6c0; /* matches tlaser pal code */ 605 ctb_tt->ctb_rintr_vec = 0x680; /* matches tlaser pal code */ 606 ctb_tt->ctb_term_type = CTB_GRAPHICS; 607 608 rpb_crb = (struct rpb_crb *) (((ulong)rpb_ctb) + sizeof(struct ctb_tt)); 609 rpb->rpb_crb_off = ((ulong)rpb_crb) - (ulong)rpb; 610 611 bzero((char *)rpb_crb, sizeof(struct rpb_crb)); 612 613 /* 614 * console callback stuff (m5) 615 */ 616 rpb_crb->rpb_num = 1; 617 rpb_crb->rpb_mapped_pages = HWRPB_PAGES; 618 rpb_crb->rpb_map[0].rpb_virt = 0x10000000; 619 rpb_crb->rpb_map[0].rpb_phys = KSEG_TO_PHYS(((ulong)rpb) & ~0x1fff); 620 rpb_crb->rpb_map[0].rpb_pgcount = HWRPB_PAGES; 621 622 printf_lock("Console Callback at 0x%x, fixup at 0x%x, crb offset: 0x%x\n", 623 rpb_crb->rpb_va_disp, rpb_crb->rpb_va_fixup, rpb->rpb_crb_off); 624 625 rpb_mdt = (struct _m5_rpb_mdt *)((ulong)rpb_crb + sizeof(struct rpb_crb)); 626 rpb->rpb_mdt_off = (ulong)rpb_mdt - (ulong)rpb; 627 bcopy((char *)&m5_rpb_mdt, (char *)rpb_mdt, sizeof(struct _m5_rpb_mdt)); 628 629 630 cl = 0; 631 rpb_mdt->rpb_cluster[cl].rpb_pfncount = kern_first_page; 632 cl++; 633 634 rpb_mdt->rpb_cluster[cl].rpb_pfn = kern_first_page; 635 rpb_mdt->rpb_cluster[cl].rpb_pfncount = mem_pages - kern_first_page; 636 rpb_mdt->rpb_cluster[cl].rpb_pfntested = 637 rpb_mdt->rpb_cluster[cl].rpb_pfncount; 638 rpb_mdt->rpb_cluster[cl].rpb_pa = KSEG_TO_PHYS(mdt_bitmap); 639 rpb_mdt->rpb_cluster[cl].rpb_va = 0x10000000 + HWRPB_PAGES * PAGE_SIZE; 640 cl++; 641 642 rpb_mdt->rpb_numcl = cl; 643 644 for (i = 0; i < cl; i++) 645 printf_lock("Memory cluster %d [%d - %d]\n", i, 646 rpb_mdt->rpb_cluster[i].rpb_pfn, 647 rpb_mdt->rpb_cluster[i].rpb_pfncount); 648 649 /* Checksum the rpb for good luck */ 650 sum = 0; 651 lp1 = (long *)&rpb_mdt->rpb_impaddr; 652 lp2 = (long *)&rpb_mdt->rpb_cluster[cl]; 653 while (lp1 < lp2) sum += *lp1++; 654 rpb_mdt->rpb_checksum = sum; 655 656 /* XXX should checksum the cluster descriptors */ 657 bzero((char *)mdt_bitmap, mdt_bitmap_pages * PAGE_SIZE); 658 for (i = 0; i < mem_pages/8; i++) 659 ((unsigned char *)mdt_bitmap)[i] = 0xff; 660 661 printf_lock("Initalizing mdt_bitmap addr 0x%x mem_pages %x \n", 662 (long)mdt_bitmap,(long)mem_pages); 663 664 m5_rpb.rpb_config_off = 0; 665 m5_rpb.rpb_fru_off = 0; 666 667 rpb_dsr = (struct rpb_dsr *)((ulong)rpb_mdt + sizeof(struct _m5_rpb_mdt)); 668 rpb->rpb_dsr_off = (ulong)rpb_dsr - (ulong)rpb; 669 bzero((char *)rpb_dsr, sizeof(struct rpb_dsr)); 670 rpb_dsr->rpb_smm = 1578; /* Official XXM SMM number as per SRM */ 671 rpb_dsr->rpb_smm = 1089; /* Official Alcor SMM number as per SRM */ 672 673 rpb_lurt = (int *) ROUNDUP8((ulong)rpb_dsr + sizeof(struct rpb_dsr)); 674 rpb_dsr->rpb_lurt_off = ((ulong) rpb_lurt) - (ulong) rpb_dsr; 675 bcopy((char *)m5_lurt, (char *)rpb_lurt, sizeof(m5_lurt)); 676 677 rpb_name = (char *) ROUNDUP8(((ulong)rpb_lurt) + sizeof(m5_lurt)); 678 rpb_dsr->rpb_sysname_off = ((ulong) rpb_name) - (ulong) rpb_dsr; 679#define THENAME " M5/Alpha " 680 sum = sizeof(THENAME); 681 bcopy(THENAME, rpb_name, sum); 682 *(ulong *)rpb_name = sizeof(THENAME); /* put in length field */ 683 684 /* calculate size of rpb */ 685 rpb->rpb_size = ((ulong) &rpb_name[sum]) - (ulong)rpb; 686 687 if (rpb->rpb_size > PAGE_SIZE * HWRPB_PAGES) { 688 panic("HWRPB_PAGES=%d too small for HWRPB !!! \n"); 689 } 690 691 ulong *rpbptr = (ulong*)((char*)rpb_dsr + sizeof(struct rpb_dsr)); 692 rpb_crb->rpb_pa_disp = KSEG_TO_PHYS(rpbptr); 693 rpb_crb->rpb_va_disp = 0x10000000 + 694 (((ulong)rpbptr - (ulong)rpb) & (0x2000 * HWRPB_PAGES - 1)); 695 printf_lock("ConsoleDispatch at virt %x phys %x val %x\n", 696 rpb_crb->rpb_va_disp, rpb_crb->rpb_pa_disp, consoleCallback); 697 *rpbptr++ = 0; 698 *rpbptr++ = (ulong) consoleCallback; 699 rpb_crb->rpb_pa_fixup = KSEG_TO_PHYS(rpbptr); 700 rpb_crb->rpb_va_fixup = 0x10000000 + 701 (((ulong)rpbptr - (ulong)rpb) & (0x2000 * HWRPB_PAGES - 1)); 702 *rpbptr++ = 0; 703 704 *rpbptr++ = (ulong) consoleFixup; 705 706 /* Checksum the rpb for good luck */ 707 sum = 0; 708 lp1 = (long *)rpb; 709 lp2 = &rpb->rpb_checksum; 710 while (lp1 < lp2) 711 sum += *lp1++; 712 *lp2 = sum; 713 714 /* 715 * MP bootstrap 716 */ 717 for (i = 1; i < m5Conf.numCPUs; i++) { 718 ulong stack = (ulong)unix_boot_alloc(1); 719 printf_lock("Bootstraping CPU %d with sp=0x%x\n", i, stack); 720 m5AlphaAccess->cpuStack[i] = stack; 721 } 722 723 /* 724 * Make sure that we are not stepping on the kernel 725 */ 726 if ((ulong)unix_boot_mem >= (ulong)m5Conf.kernStart) { 727 panic("CONSOLE: too much memory. Smashing kernel\n"); 728 } else { 729 printf_lock("unix_boot_mem ends at %x \n", unix_boot_mem); 730 } 731 732 JToKern((char *)bootadr, (ulong)rpb_percpu, free_pfn, kargc, kargv, NULL); 733} 734 735 736void 737JToKern(char *bootadr, ulong rpb_percpu, ulong free_pfn, ulong k_argc, 738 char **k_argv, char **envp) 739{ 740 extern ulong palJToKern[]; 741 742 struct _kernel_params *kernel_params = (struct _kernel_params *) KSEG; 743 int i; 744 745 printf_lock("k_argc = %d ", k_argc); 746 for (i = 0; i < k_argc; i++) { 747 printf_lock("'%s' ", k_argv[i]); 748 } 749 printf_lock("\n"); 750 751 kernel_params->bootadr = bootadr; 752 kernel_params->rpb_percpu = KSEG_TO_PHYS(rpb_percpu); 753 kernel_params->free_pfn = free_pfn; 754 kernel_params->argc = k_argc; 755 kernel_params->argv = (ulong)k_argv; 756 kernel_params->envp = (ulong)envp; 757 printf_lock("jumping to kernel at 0x%x, (PCBB 0x%x pfn %d)\n", 758 bootadr, rpb_percpu, free_pfn); 759 JToPal(KSEG_TO_PHYS(palJToKern)); 760 printf_lock("returned from JToPal. Looping\n"); 761 while (1) 762 continue; 763} 764 765void 766JToPal(ulong bootadr) 767{ 768 cServe(bootadr, 0, CSERVE_K_JTOPAL); 769 770 /* 771 * Make sure that floating point is enabled incase 772 * it was disabled by the user program. 773 */ 774 wrfen(1); 775} 776 777int 778strcpy(char *dst, char *src) 779{ 780 int i = 0; 781 while (*src) { 782 *dst++ = *src++; 783 i++; 784 } 785 return i; 786} 787 788/* 789 * Console I/O 790 * 791 */ 792 793int numOpenDevices = 11; 794struct { 795 char name[128]; 796} deviceState[32]; 797 798#define BOOTDEVICE_NAME "SCSI 1 0 0 1 100 0" 799 800void 801DeviceOperation(long op, long channel, long count, long address, long block) 802{ 803 long pAddr; 804 805 if (strcmp(deviceState[channel].name, BOOTDEVICE_NAME )) { 806 panic("DeviceRead: only implemented for root disk \n"); 807 } 808 pAddr = KSEG_TO_PHYS(address); 809 if (pAddr + count > m5Conf.mem_size) { 810 panic("DeviceRead: request out of range \n"); 811 } 812 813 m5AlphaAccess->diskCount = count; 814 m5AlphaAccess->diskPAddr = pAddr; 815 m5AlphaAccess->diskBlock = block; 816 m5AlphaAccess->diskOperation = op; /* launch */ 817} 818 819/* 820 * M5 Console callbacks 821 * 822 */ 823 824/* AXP manual 2-31 */ 825#define CONSCB_GETC 0x1 826#define CONSCB_PUTS 0x2 827#define CONSCB_RESET_TERM 0x3 828#define CONSCB_SET_TERM_INT 0x4 829#define CONSCB_SET_TERM_CTL 0x5 830#define CONSCB_PROCESS_KEY 0x6 831#define CONSCB_OPEN_CONSOLE 0x7 832#define CONSCB_CLOSE_CONSOLE 0x8 833 834#define CONSCB_OPEN 0x10 835#define CONSCB_CLOSE 0x11 836#define CONSCB_READ 0x13 837 838#define CONSCB_GETENV 0x22 839 840/* AXP manual 2-26 */ 841#define ENV_AUTO_ACTION 0X01 842#define ENV_BOOT_DEV 0X02 843#define ENV_BOOTDEF_DEV 0X03 844#define ENV_BOOTED_DEV 0X04 845#define ENV_BOOT_FILE 0X05 846#define ENV_BOOTED_FILE 0X06 847#define ENV_BOOT_OSFLAGS 0X07 848#define ENV_BOOTED_OSFLAGS 0X08 849#define ENV_BOOT_RESET 0X09 850#define ENV_DUMP_DEV 0X0A 851#define ENV_ENABLE_AUDIT 0X0B 852#define ENV_LICENSE 0X0C 853#define ENV_CHAR_SET 0X0D 854#define ENV_LANGUAGE 0X0E 855#define ENV_TTY_DEV 0X0F 856#define ENV_SCSIID 0X42 857#define ENV_SCSIFAST 0X43 858#define ENV_COM1_BAUD 0X44 859#define ENV_COM1_MODEM 0X45 860#define ENV_COM1_FLOW 0X46 861#define ENV_COM1_MISC 0X47 862#define ENV_COM2_BAUD 0X48 863#define ENV_COM2_MODEM 0X49 864#define ENV_COM2_FLOW 0X4A 865#define ENV_COM2_MISC 0X4B 866#define ENV_PASSWORD 0X4C 867#define ENV_SECURE 0X4D 868#define ENV_LOGFAIL 0X4E 869#define ENV_SRM2DEV_ID 0X4F 870 871#define MAX_ENVLEN 32 872 873char env_auto_action[MAX_ENVLEN] = "BOOT"; 874char env_boot_dev[MAX_ENVLEN] = ""; 875char env_bootdef_dev[MAX_ENVLEN] = ""; 876char env_booted_dev[MAX_ENVLEN] = BOOTDEVICE_NAME; 877char env_boot_file[MAX_ENVLEN] = ""; 878char env_booted_file[MAX_ENVLEN] = ""; 879char env_boot_osflags[MAX_ENVLEN] = ""; 880char env_booted_osflags[MAX_ENVLEN] = ""; 881char env_boot_reset[MAX_ENVLEN] = ""; 882char env_dump_dev[MAX_ENVLEN] = ""; 883char env_enable_audit[MAX_ENVLEN] = ""; 884char env_license[MAX_ENVLEN] = ""; 885char env_char_set[MAX_ENVLEN] = ""; 886char env_language[MAX_ENVLEN] = ""; 887char env_tty_dev[MAX_ENVLEN] = "0"; 888char env_scsiid[MAX_ENVLEN] = ""; 889char env_scsifast[MAX_ENVLEN] = ""; 890char env_com1_baud[MAX_ENVLEN] = ""; 891char env_com1_modem[MAX_ENVLEN] = ""; 892char env_com1_flow[MAX_ENVLEN] = ""; 893char env_com1_misc[MAX_ENVLEN] = ""; 894char env_com2_baud[MAX_ENVLEN] = ""; 895char env_com2_modem[MAX_ENVLEN] = ""; 896char env_com2_flow[MAX_ENVLEN] = ""; 897char env_com2_misc[MAX_ENVLEN] = ""; 898char env_password[MAX_ENVLEN] = ""; 899char env_secure[MAX_ENVLEN] = ""; 900char env_logfail[MAX_ENVLEN] = ""; 901char env_srm2dev_id[MAX_ENVLEN] = ""; 902 903#define MAX_ENV_INDEX 100 904char *envptr[MAX_ENV_INDEX] = { 905 0, /* 0x00 */ 906 env_auto_action, /* 0x01 */ 907 env_boot_dev, /* 0x02 */ 908 env_bootdef_dev, /* 0x03 */ 909 env_booted_dev, /* 0x04 */ 910 env_boot_file, /* 0x05 */ 911 env_booted_file, /* 0x06 */ 912 env_boot_osflags, /* 0x07 */ 913 env_booted_osflags, /* 0x08 */ 914 env_boot_reset, /* 0x09 */ 915 env_dump_dev, /* 0x0A */ 916 env_enable_audit, /* 0x0B */ 917 env_license, /* 0x0C */ 918 env_char_set, /* 0x0D */ 919 (char *)&env_language, /* 0x0E */ 920 env_tty_dev, /* 0x0F */ 921 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, /* 0x10 - 0x1F */ 922 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, /* 0x20 - 0x2F */ 923 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, /* 0x30 - 0x3F */ 924 0, /* 0x40 */ 925 0, /* 0x41 */ 926 env_scsiid, /* 0x42 */ 927 env_scsifast, /* 0x43 */ 928 env_com1_baud, /* 0x44 */ 929 env_com1_modem, /* 0x45 */ 930 env_com1_flow, /* 0x46 */ 931 env_com1_misc, /* 0x47 */ 932 env_com2_baud, /* 0x48 */ 933 env_com2_modem, /* 0x49 */ 934 env_com2_flow, /* 0x4A */ 935 env_com2_misc, /* 0x4B */ 936 env_password, /* 0x4C */ 937 env_secure, /* 0x4D */ 938 env_logfail, /* 0x4E */ 939 env_srm2dev_id, /* 0x4F */ 940 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, /* 0x50 - 0x5F */ 941 0, /* 0x60 */ 942 0, /* 0x61 */ 943 0, /* 0x62 */ 944 0, /* 0x63 */ 945}; 946 947long 948CallBackDispatcher(long a0, long a1, long a2, long a3, long a4) 949{ 950 long i; 951 switch (a0) { 952 case CONSCB_GETC: 953 return GetChar(); 954 955 case CONSCB_PUTS: 956 for (i = 0; i < a3; i++) 957 PutChar(*((char *)a2 + i)); 958 return a3; 959 960 case CONSCB_GETENV: 961 if (a1 >= 0 && a1 < MAX_ENV_INDEX && envptr[a1] != 0 && *envptr[a1]) { 962 i = strcpy((char*)a2, envptr[a1]); 963 } else { 964 strcpy((char*)a2, ""); 965 i = (long)0xc000000000000000; 966 if (a1 >= 0 && a1 < MAX_ENV_INDEX) 967 printf_lock("GETENV unsupported option %d (0x%x)\n", a1, a1); 968 else 969 printf_lock("GETENV unsupported option %s\n", a1); 970 } 971 972 if (i > a3) 973 panic("CONSCB_GETENV overwrote buffer\n"); 974 return i; 975 976 case CONSCB_OPEN: 977 bcopy((char*)a1, deviceState[numOpenDevices].name, a2); 978 deviceState[numOpenDevices].name[a2] = '\0'; 979 printf_lock("CONSOLE OPEN : %s --> success \n", 980 deviceState[numOpenDevices].name); 981 return numOpenDevices++; 982 983 case CONSCB_READ: 984 DeviceOperation(a0, a1, a2, a3, a4); 985 break; 986 987 case CONSCB_CLOSE: 988 break; 989 990 case CONSCB_OPEN_CONSOLE: 991 printf_lock("CONSOLE OPEN\n"); 992 return 0; /* success */ 993 break; /* not reached */ 994 995 case CONSCB_CLOSE_CONSOLE: 996 printf_lock("CONSOLE CLOSE\n"); 997 return 0; /* success */ 998 break; /* not reached */ 999 1000 default: 1001 panic("CallBackDispatcher(%x,%x,%x,%x,%x)\n", a0, a1, a2, a3, a4); 1002 } 1003 1004 return 0; 1005} 1006 1007long 1008CallBackFixup(int a0, int a1, int a2) 1009{ 1010 long temp; 1011 /* 1012 * Linux uses r8 for the current pointer (pointer to data 1013 * structure contating info about currently running process). It 1014 * is set when the kernel starts and is expected to remain 1015 * there... Problem is that the unlike the kernel, the console 1016 * does not prevent the assembler from using r8. So here is a work 1017 * around. So far this has only been a problem in CallBackFixup() 1018 * but any other call back functions couldd cause a problem at 1019 * some point 1020 */ 1021 1022 /* save off the current pointer to a temp variable */ 1023 asm("bis $8, $31, %0" : "=r" (temp)); 1024 1025 /* call original code */ 1026 printf_lock("CallbackFixup %x %x, t7=%x\n", a0, a1, temp); 1027 1028 /* restore the current pointer */ 1029 asm("bis %0, $31, $8" : : "r" (temp) : "$8"); 1030 1031 return 0; 1032} 1033 1034void 1035SlaveCmd(int cpu, struct rpb_percpu *my_rpb) 1036{ 1037 extern ulong palJToSlave[]; 1038 1039 printf_lock("Slave CPU %d console command %s", cpu, 1040 my_rpb->rpb_iccb.iccb_rxbuf); 1041 1042 my_rpb->rpb_state |= STATE_BIP; 1043 my_rpb->rpb_state &= ~STATE_RC; 1044 1045 printf_lock("SlaveCmd: restart %x %x vptb %x my_rpb %x my_rpb_phys %x\n", 1046 rpb->rpb_restart, rpb->rpb_restart_pv, rpb->rpb_vptb, my_rpb, 1047 KSEG_TO_PHYS(my_rpb)); 1048 1049 cServe(KSEG_TO_PHYS(palJToSlave), (ulong)rpb->rpb_restart, 1050 CSERVE_K_JTOPAL, rpb->rpb_restart_pv, rpb->rpb_vptb, 1051 KSEG_TO_PHYS(my_rpb)); 1052 1053 panic("SlaveCmd returned \n"); 1054} 1055 1056void 1057SlaveLoop(int cpu) 1058{ 1059 int size = ROUNDUP128(sizeof(struct rpb_percpu)); 1060 struct rpb_percpu *my_rpb = (struct rpb_percpu*) 1061 ((ulong)rpb_percpu + size * cpu); 1062 1063 if (cpu == 0) { 1064 panic("CPU�0 entering slaveLoop. Reenetering the console. HOSED\n"); 1065 } else { 1066 printf_lock("Entering slaveloop for cpu %d my_rpb=%x\n", cpu, my_rpb); 1067 } 1068 1069 // swap the processors context to the one in the 1070 // rpb_percpu struct very carefully (i.e. no stack usage) 1071 // so that linux knows which processor ends up in __smp_callin 1072 // and we don't trash any data is the process 1073 SlaveSpin(cpu, my_rpb, &my_rpb->rpb_iccb.iccb_rxlen); 1074} 1075