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