1 /* $NetBSD: machdep.c,v 1.9 2024/03/05 14:15:30 thorpej Exp $ */ 2 3 /* 4 * Copyright 2001, 2002 Wasabi Systems, Inc. 5 * All rights reserved. 6 * 7 * Written by Jason R. Thorpe and Simon Burge for Wasabi Systems, Inc. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. All advertising materials mentioning features or use of this software 18 * must display the following acknowledgement: 19 * This product includes software developed for the NetBSD Project by 20 * Wasabi Systems, Inc. 21 * 4. The name of Wasabi Systems, Inc. may not be used to endorse 22 * or promote products derived from this software without specific prior 23 * written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND 26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 27 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 28 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC 29 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35 * POSSIBILITY OF SUCH DAMAGE. 36 */ 37 38 /* 39 * Copyright (c) 1988 University of Utah. 40 * Copyright (c) 1992, 1993 41 * The Regents of the University of California. All rights reserved. 42 * 43 * This code is derived from software contributed to Berkeley by 44 * the Systems Programming Group of the University of Utah Computer 45 * Science Department, The Mach Operating System project at 46 * Carnegie-Mellon University and Ralph Campbell. 47 * 48 * Redistribution and use in source and binary forms, with or without 49 * modification, are permitted provided that the following conditions 50 * are met: 51 * 1. Redistributions of source code must retain the above copyright 52 * notice, this list of conditions and the following disclaimer. 53 * 2. Redistributions in binary form must reproduce the above copyright 54 * notice, this list of conditions and the following disclaimer in the 55 * documentation and/or other materials provided with the distribution. 56 * 3. Neither the name of the University nor the names of its contributors 57 * may be used to endorse or promote products derived from this software 58 * without specific prior written permission. 59 * 60 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 61 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 62 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 63 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 64 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 65 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 66 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 67 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 68 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 69 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 70 * SUCH DAMAGE. 71 * 72 * @(#)machdep.c 8.3 (Berkeley) 1/12/94 73 * from: Utah Hdr: machdep.c 1.63 91/04/24 74 */ 75 76 /* 77 * Copyright (c) 2009, 2010 Miodrag Vallat. 78 * 79 * Permission to use, copy, modify, and distribute this software for any 80 * purpose with or without fee is hereby granted, provided that the above 81 * copyright notice and this permission notice appear in all copies. 82 * 83 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 84 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 85 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 86 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 87 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 88 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 89 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 90 */ 91 92 #include <sys/cdefs.h> 93 __KERNEL_RCSID(0, "$NetBSD: machdep.c,v 1.9 2024/03/05 14:15:30 thorpej Exp $"); 94 95 #include "opt_ddb.h" 96 #include "opt_execfmt.h" 97 #include "opt_modular.h" 98 99 #define _MIPS_BUS_DMA_PRIVATE 100 101 #include <sys/param.h> 102 #include <sys/systm.h> 103 #include <sys/kernel.h> 104 #include <sys/buf.h> 105 #include <sys/reboot.h> 106 #include <sys/mount.h> 107 #include <sys/kcore.h> 108 #include <sys/boot_flag.h> 109 #include <sys/termios.h> 110 #include <sys/ksyms.h> 111 #include <sys/device.h> 112 #include <sys/cpu.h> 113 114 #include <uvm/uvm_extern.h> 115 116 #include <dev/cons.h> 117 118 #include "ksyms.h" 119 120 #if NKSYMS || defined(DDB) || defined(MODULAR) 121 #include <machine/db_machdep.h> 122 #include <ddb/db_extern.h> 123 #include <sys/exec_elf.h> 124 #endif 125 126 #include <evbmips/loongson/autoconf.h> 127 #include <evbmips/loongson/loongson_intr.h> 128 #include <evbmips/loongson/loongson_bus_defs.h> 129 #include <machine/cpu.h> 130 #include <machine/psl.h> 131 132 #include <mips/locore.h> 133 134 #include <mips/bonito/bonitoreg.h> 135 #include <mips/bonito/bonitovar.h> 136 #include <mips/pmon/pmon.h> 137 138 #include "sisfb.h" 139 #if NSISFB > 0 140 #include <dev/pci/sisfb.h> 141 #endif 142 143 #include "lynxfb.h" 144 #if NLYNXFB > 0 145 #include <dev/pci/lynxfbvar.h> 146 #endif 147 148 #include "pckbc.h" 149 #if NPCKBC > 0 150 #include <dev/isa/isareg.h> 151 #include <dev/ic/i8042reg.h> 152 #include <dev/ic/pckbcvar.h> 153 #endif 154 #include "pckbd.h" 155 #include "ukbd.h" 156 #if NUKBD > 0 157 #include <dev/usb/ukbdvar.h> 158 #endif 159 #if NPCKBD > 0 || NUKBD > 0 160 #include <dev/wscons/wskbdvar.h> 161 #endif 162 163 #include "com.h" 164 #if NCOM > 0 165 #include <dev/ic/comreg.h> 166 #include <dev/ic/comvar.h> 167 168 bus_space_tag_t comconsiot; 169 bus_addr_t comconsaddr; 170 int comconsrate = 0; 171 #endif /* NCOM > 0 */ 172 173 #ifdef LOW_DEBUG 174 #define DPRINTF(x) printf x 175 #define DPPRINTF(x) pmon_printf x 176 #else 177 #define DPRINTF(x) 178 #define DPPRINTF(x) 179 #endif 180 181 182 int ex_mallocsafe = 0; 183 struct extent *loongson_io_ex = NULL; 184 struct extent *loongson_mem_ex = NULL; 185 struct mips_bus_space bonito_iot; 186 struct mips_bus_space bonito_memt; 187 struct mips_bus_dma_tag bonito_dmat; 188 struct mips_pci_chipset bonito_pc; 189 190 uint loongson_ver; 191 192 const struct platform *sys_platform; 193 struct bonito_flavour { 194 const char *prefix; 195 const struct platform *platform; 196 }; 197 198 extern const struct platform fuloong_platform; 199 extern const struct platform gdium_platform; 200 extern const struct platform generic2e_platform; 201 extern const struct platform lynloong_platform; 202 extern const struct platform yeeloong_platform; 203 204 const struct bonito_flavour bonito_flavours[] = { 205 /* Lemote Fuloong 2F mini-PC */ 206 { "LM6002", &fuloong_platform }, /* dual Ethernet, no prefix */ 207 { "LM6003", &fuloong_platform }, 208 { "LM6004", &fuloong_platform }, 209 /* EMTEC Gdium Liberty 1000 */ 210 { "Gdium", &gdium_platform }, 211 /* Lemote Yeeloong 8.9" netbook */ 212 { "LM8089", &yeeloong_platform }, 213 /* supposedly Lemote Yeeloong 10.1" netbook, but those found so far 214 report themselves as LM8089 */ 215 { "LM8101", &yeeloong_platform }, 216 /* Lemote Lynloong all-in-one computer */ 217 { "LM9001", &lynloong_platform }, 218 { NULL } 219 }; 220 221 /* Maps for VM objects. */ 222 struct vm_map *phys_map = NULL; 223 224 int netboot; /* Are we netbooting? */ 225 226 phys_ram_seg_t mem_clusters[VM_PHYSSEG_MAX]; 227 int mem_cluster_cnt; 228 229 void mach_init(int, int32_t, int32_t, int32_t, char *); 230 231 static int pmoncngetc(dev_t); 232 static void pmoncnputc(dev_t, int); 233 234 struct consdev pmoncons = { 235 NULL, /* probe */ 236 NULL, /* init */ 237 pmoncngetc, /* getc */ 238 pmoncnputc, /* putc */ 239 nullcnpollc, /* poolc */ 240 NULL, /* BELL */ 241 makedev(0, 0), 242 CN_DEAD 243 }; 244 245 /* The LOONGSON kernels only support little endian */ 246 CTASSERT(_BYTE_ORDER == _LITTLE_ENDIAN); 247 248 /* 249 * Do all the stuff that locore normally does before calling main(). 250 */ 251 void 252 mach_init(int32_t argc, int32_t argva, int32_t enva, int32_t callvec, 253 char *boot_esym) 254 { 255 void *kernend; 256 #ifdef NOTYET 257 int howto; 258 #endif 259 const char *env; 260 int i; 261 psize_t memlo, memhi; 262 const struct bonito_flavour *f; 263 char *ssym = NULL, *esym = NULL; 264 pcireg_t reg; 265 pcitag_t pcitag; 266 267 extern char edata[], end[]; 268 269 /* 270 * Clear the BSS segment. 271 */ 272 memset(edata, 0, (char *)end - edata); 273 274 pmon_init(argc, argva, enva, callvec); 275 DPPRINTF(("pmon hello\n")); 276 277 cn_tab = &pmoncons; 278 279 DPRINTF(("hello 0x%x %d 0x%x 0x%x %p stack %p\n", pmon_callvec, argc, argva, enva, boot_esym, &i)); 280 281 /* 282 * Reserve space for the symbol table, if it exists. 283 */ 284 285 #if NKSYMS || defined(DDB) || defined(MODULAR) 286 /* Attempt to locate ELF header and symbol table after kernel. */ 287 if (end[0] == ELFMAG0 && end[1] == ELFMAG1 && 288 end[2] == ELFMAG2 && end[3] == ELFMAG3) { 289 /* ELF header exists directly after kernel. */ 290 ssym = end; 291 esym = boot_esym; 292 kernend = (void *)mips_round_page(esym); 293 } else { 294 ssym = (char *)(vaddr_t)*(int32_t *)end; 295 if (((long)ssym - (long)end) >= 0 && 296 ((long)ssym - (long)end) <= 0x1000 && 297 ssym[0] == ELFMAG0 && ssym[1] == ELFMAG1 && 298 ssym[2] == ELFMAG2 && ssym[3] == ELFMAG3) { 299 /* Pointers exist directly after kernel. */ 300 esym = (char *)(vaddr_t)*((int32_t *)end + 1); 301 kernend = (void *)mips_round_page(esym); 302 } else { 303 /* Pointers aren't setup either... */ 304 ssym = NULL; 305 esym = NULL; 306 kernend = (void *)mips_round_page(end); 307 } 308 } 309 DPRINTF(("ssym %p esym %p\n", ssym, esym)); 310 #endif 311 312 /* 313 * Set up the exception vectors and CPU-specific function 314 * vectors early on. We need the wbflush() vector set up 315 * before comcnattach() is called (or at least before the 316 * first printf() after that is called). 317 * Also clears the I+D caches. 318 */ 319 DPRINTF(("mips_vector_init ")); 320 mips_vector_init(NULL, false); 321 322 DPRINTF(("uvm_md_init\n")); 323 uvm_md_init(); 324 #if NKSYMS || defined(DDB) || defined(MODULAR) 325 //ksyms_addsyms_elf((vaddr_t)esym - (vaddr_t)ssym, ssym, esym); 326 #endif 327 328 /* 329 * Try and figure out what kind of hardware we are. 330 */ 331 332 env = pmon_getenv("systype"); 333 if (env == NULL) { 334 printf("Unable to figure out system type!\n"); 335 goto unsupported; 336 } 337 if (strcmp(env, "Bonito") != 0) { 338 printf("This kernel doesn't support system type \"%s\".\n", 339 env); 340 goto unsupported; 341 } 342 343 /* 344 * While the kernel supports other processor types than Loongson, 345 * we are not expecting a Bonito-based system with a different 346 * processor. Just to be on the safe side, refuse to run on 347 * non Loongson2 processors for now. 348 */ 349 350 switch ((mips_options.mips_cpu_id >> 8) & 0xff) { 351 case MIPS_LOONGSON2: 352 switch (mips_options.mips_cpu_id & 0xff) { 353 case 0x00: 354 loongson_ver = 0x2c; 355 break; 356 case 0x02: 357 loongson_ver = 0x2e; 358 break; 359 case 0x03: 360 loongson_ver = 0x2f; 361 break; 362 case 0x05: 363 loongson_ver = 0x3a; 364 break; 365 } 366 if (loongson_ver == 0x2e || loongson_ver == 0x2f) 367 break; 368 /* FALLTHROUGH */ 369 default: 370 printf("This kernel doesn't support processor type 0x%x" 371 ", version %d.%d.\n", 372 (mips_options.mips_cpu_id >> 8) & 0xff, 373 (mips_options.mips_cpu_id >> 4) & 0x0f, 374 mips_options.mips_cpu_id & 0x0f); 375 goto unsupported; 376 } 377 378 /* 379 * Try to figure out what particular machine we run on, depending 380 * on the PMON version information. 381 */ 382 383 env = pmon_getenv("Version"); 384 if (env == NULL) { 385 /* 386 * If this is a 2E system, use the generic code and hope 387 * for the best. 388 */ 389 if (loongson_ver == 0x2e) { 390 sys_platform = &generic2e_platform; 391 } else { 392 printf("Unable to figure out model!\n"); 393 goto unsupported; 394 } 395 } else { 396 for (f = bonito_flavours; f->prefix != NULL; f++) 397 if (strncmp(env, f->prefix, strlen(f->prefix)) == 398 0) { 399 sys_platform = f->platform; 400 break; 401 } 402 403 if (sys_platform == NULL) { 404 /* 405 * Early Lemote designs shipped without a model prefix. 406 * Hopefully these well be close enough to the first 407 * generation Fuloong 2F design (LM6002); let's warn 408 * the user and try this if version is 1.2.something 409 * (1.3 onwards are expected to have a model prefix, 410 * and there are currently no reports of 1.1 and 411 * below being 2F systems). 412 * 413 * Note that this could be handled by adding a 414 * "1.2." machine type entry to the flavours table, 415 * but I prefer have it stand out. 416 * LM6002 users are encouraged to add the system 417 * model prefix to the `Version' variable. 418 */ 419 if (strncmp(env, "1.2.", 4) == 0) { 420 printf("No model prefix in version" 421 " string \"%s\".\n" 422 "Attempting to match as Lemote Fuloong\n", 423 env); 424 sys_platform = &fuloong_platform; 425 } 426 } 427 428 if (sys_platform == NULL) { 429 printf("This kernel doesn't support model \"%s\"." 430 "\n", env); 431 goto unsupported; 432 } 433 } 434 435 cpu_setmodel("%s %s", sys_platform->vendor, sys_platform->product); 436 DPRINTF(("Found %s, setting up.\n", cpu_getmodel())); 437 438 /* 439 * Figure out memory information. 440 * PMON reports it in two chunks, the memory under the 256MB 441 * CKSEG limit, and memory above that limit. We need to do the 442 * math ourselves. 443 */ 444 445 env = pmon_getenv("memsize"); 446 if (env == NULL) { 447 printf("Could not get memory information" 448 " from the firmware\n"); 449 goto unsupported; 450 } 451 memlo = strtoul(env, NULL, 10); /* size in MB */ 452 DPRINTF(("memlo %" PRIdPSIZE, memlo)); 453 if (memlo < 0 || memlo > 256) { 454 printf("Incorrect low memory size `%s'\n", env); 455 goto unsupported; 456 } 457 458 /* 3A PMON only reports up to 240MB as low memory */ 459 if (memlo >= 240) { 460 env = pmon_getenv("highmemsize"); 461 if (env == NULL) 462 memhi = 0; 463 else 464 memhi = strtoul(env, NULL, 10); /* size in MB */ 465 if (memhi < 0 || memhi > (64 * 1024) - 256) { 466 printf("Incorrect high memory size `%s'\n", 467 env); 468 /* better expose the problem than limit to 256MB */ 469 goto unsupported; 470 } 471 } else 472 memhi = 0; 473 474 DPRINTF(("memhi %" PRIdPSIZE "\n", memhi)); 475 memlo = memlo * 1024 * 1024; 476 memhi = memhi * 1024 * 1024; 477 478 switch (loongson_ver) { 479 case 0x2e: 480 loongson2e_setup(memlo, memhi, 481 MIPS_KSEG0_START, (vaddr_t)kernend, &bonito_dmat); 482 break; 483 default: 484 case 0x2f: 485 case 0x3a: 486 loongson2f_setup(memlo, memhi, 487 MIPS_KSEG0_START, (vaddr_t)kernend, &bonito_dmat); 488 break; 489 } 490 491 DPRINTF(("bonito_pci_init ")); 492 bonito_pci_init(&bonito_pc, sys_platform->bonito_config); 493 bonito_pc.pc_intr_v = __UNCONST(sys_platform->bonito_config); 494 bonito_pc.pc_intr_map = loongson_pci_intr_map; 495 bonito_pc.pc_intr_string = loongson_pci_intr_string; 496 bonito_pc.pc_intr_evcnt = loongson_pci_intr_evcnt; 497 bonito_pc.pc_intr_establish = loongson_pci_intr_establish; 498 bonito_pc.pc_intr_disestablish = loongson_pci_intr_disestablish; 499 bonito_pc.pc_conf_interrupt = loongson_pci_conf_interrupt; 500 bonito_pc.pc_pciide_compat_intr_establish = 501 loongson_pciide_compat_intr_establish; 502 DPRINTF(("bonito_bus_io_init ")); 503 bonito_bus_io_init(&bonito_iot, NULL); 504 /* override mapping function */ 505 bonito_iot.bs_map = bonito_bus_io_legacy_map; 506 DPRINTF(("bonito_bus_mem_init\n")); 507 bonito_bus_mem_init(&bonito_memt, NULL); 508 509 bonito_dmat._cookie = __UNCONST(sys_platform); 510 bonito_dmat._dmamap_ops = mips_bus_dmamap_ops; 511 bonito_dmat._dmamem_ops = mips_bus_dmamem_ops; 512 bonito_dmat._dmatag_ops = mips_bus_dmatag_ops; 513 514 DPRINTF(("sys_platform->setup %p\n", sys_platform->setup)); 515 if (sys_platform->setup != NULL) 516 (*(sys_platform->setup))(); 517 518 #if NCOM > 0 519 DPRINTF(("comconsrate %d\n", comconsrate)); 520 if (comconsrate > 0) { 521 if (comcnattach(comconsiot, comconsaddr, comconsrate, 522 COM_FREQ, COM_TYPE_NORMAL, 523 (TTYDEF_CFLAG & ~(CSIZE | PARENB)) | CS8) != 0) 524 panic("unable to initialize serial console"); 525 } 526 #endif /* NCOM > 0 */ 527 528 for (i = 0; i < 32 - 0x11; i++) { 529 pcitag = pci_make_tag(&bonito_pc, 0, i, 0); 530 reg = pci_conf_read(&bonito_pc, pcitag, PCI_CLASS_REG); 531 DPRINTF(("dev %d class 0x%x", i, reg)); 532 reg = pci_conf_read(&bonito_pc, pcitag, PCI_ID_REG); 533 DPRINTF((" id 0x%x; ", reg)); 534 #if NSISFB > 0 535 if (cn_tab == &pmoncons) 536 sisfb_cnattach(&bonito_memt, &bonito_iot, &bonito_pc, 537 pcitag, reg); 538 #endif 539 #if NLYNXFB > 0 540 if (cn_tab == &pmoncons) 541 lynxfb_cnattach(&bonito_memt, &bonito_iot, &bonito_pc, 542 pcitag, reg); 543 #endif 544 if (cn_tab == &pmoncons) 545 gdium_cnattach(&bonito_memt, &bonito_iot, &bonito_pc, 546 pcitag, reg); 547 if (cn_tab != &pmoncons) 548 break; 549 } 550 #if NPCKBC > 0 || NUKBD > 0 551 if (cn_tab != &pmoncons) { 552 int rc = ENXIO; 553 #if NPCKBC > 0 554 if (rc != 0) 555 rc = pckbc_cnattach(&bonito_iot, IO_KBD, KBCMDP, 0, 0); 556 #endif 557 #if NUKBD > 0 558 if (rc != 0) 559 rc = ukbd_cnattach(); 560 #endif 561 } 562 #endif /* NPCKBC > 0 || NUKBD > 0 */ 563 DPRINTF(("\n")); 564 565 /* 566 * Get the timer from PMON. 567 */ 568 DPRINTF(("search cpuclock ")); 569 env = pmon_getenv("cpuclock"); 570 DPRINTF(("got %s ", env)); 571 if (env != NULL) { 572 curcpu()->ci_cpu_freq = 573 strtoul(env, NULL, 10); 574 } 575 576 DPRINTF(("cpuclock %ld\n", curcpu()->ci_cpu_freq)); 577 578 if (mips_options.mips_cpu_flags & CPU_MIPS_DOUBLE_COUNT) 579 curcpu()->ci_cpu_freq /= 2; 580 581 582 /* Compute the number of ticks for hz. */ 583 curcpu()->ci_cycles_per_hz = (curcpu()->ci_cpu_freq + hz / 2) / hz; 584 585 /* Compute the delay divisor. */ 586 curcpu()->ci_divisor_delay = 587 ((curcpu()->ci_cpu_freq + 500000) / 1000000); 588 589 /* 590 * Get correct cpu frequency if the CPU runs at twice the 591 * external/cp0-count frequency. 592 */ 593 if (mips_options.mips_cpu_flags & CPU_MIPS_DOUBLE_COUNT) 594 curcpu()->ci_cpu_freq *= 2; 595 596 #ifdef DEBUG 597 printf("Timer calibration: %lu cycles/sec\n", 598 curcpu()->ci_cpu_freq); 599 #endif 600 601 #if NCOM > 0 && 0 602 /* 603 * Delay to allow firmware putchars to complete. 604 * FIFO depth * character time. 605 * character time = (1000000 / (defaultrate / 10)) 606 */ 607 delay(160000000 / comcnrate); 608 if (comcnattach(&gc->gc_iot, MALTA_UART0ADR, comcnrate, 609 COM_FREQ, COM_TYPE_NORMAL, 610 (TTYDEF_CFLAG & ~(CSIZE | PARENB)) | CS8) != 0) 611 panic("malta: unable to initialize serial console"); 612 #endif /* NCOM > 0 */ 613 614 /* 615 * XXX: check argv[0] - do something if "gdb"??? 616 */ 617 618 /* 619 * Look at arguments passed to us and compute boothowto. 620 */ 621 boothowto = RB_AUTOBOOT; 622 #ifdef NOTYET 623 for (i = 1; i < argc; i++) { 624 for (cp = argv[i]; *cp; cp++) { 625 /* Ignore superfluous '-', if there is one */ 626 if (*cp == '-') 627 continue; 628 629 howto = 0; 630 BOOT_FLAG(*cp, howto); 631 if (! howto) 632 printf("bootflag '%c' not recognised\n", *cp); 633 else 634 boothowto |= howto; 635 } 636 } 637 #endif 638 639 /* 640 * Load the rest of the available pages into the VM system. 641 */ 642 mips_page_physload(MIPS_KSEG0_START, (vaddr_t)kernend, 643 mem_clusters, mem_cluster_cnt, NULL, 0); 644 645 /* 646 * Initialize error message buffer (at end of core). 647 */ 648 DPRINTF(("mips_init_msgbuf\n")); 649 mips_init_msgbuf(); 650 651 DPRINTF(("pmap_bootstrap\n")); 652 pmap_bootstrap(); 653 654 /* 655 * Allocate uarea page for lwp0 and set it. 656 */ 657 DPRINTF(("curlwp %p ", curlwp)); 658 DPRINTF(("curlwp stack %p\n", curlwp->l_addr)); 659 mips_init_lwp0_uarea(); 660 661 DPRINTF(("curlwp %p ", curlwp)); 662 DPRINTF(("curlwp stack %p\n", curlwp->l_addr)); 663 664 /* 665 * Initialize debuggers, and break into them, if appropriate. 666 */ 667 #if defined(DDB) 668 if (boothowto & RB_KDB) 669 Debugger(); 670 #endif 671 DPRINTF(("return\n")); 672 return; 673 unsupported: 674 panic("unsupported hardware\n"); 675 } 676 677 void 678 consinit(void) 679 { 680 681 /* 682 * Everything related to console initialization is done 683 * in mach_init(). 684 */ 685 } 686 687 /* 688 * Allocate memory for variable-sized tables, 689 */ 690 void 691 cpu_startup(void) 692 { 693 /* 694 * Do the common startup items. 695 */ 696 cpu_startup_common(); 697 698 /* 699 * Virtual memory is bootstrapped -- notify the bus spaces 700 * that memory allocation is now safe. 701 */ 702 ex_mallocsafe = 1; 703 } 704 705 int waittime = -1; 706 707 void 708 cpu_reboot(int howto, char *bootstr) 709 { 710 711 /* Take a snapshot before clobbering any registers. */ 712 savectx(curpcb); 713 714 if (cold) { 715 howto |= RB_HALT; 716 goto haltsys; 717 } 718 719 /* If "always halt" was specified as a boot flag, obey. */ 720 if (boothowto & RB_HALT) 721 howto |= RB_HALT; 722 723 boothowto = howto; 724 if ((howto & RB_NOSYNC) == 0 && (waittime < 0)) { 725 waittime = 0; 726 vfs_shutdown(); 727 } 728 729 splhigh(); 730 731 if (howto & RB_DUMP) 732 dumpsys(); 733 734 haltsys: 735 doshutdownhooks(); 736 737 pmf_system_shutdown(boothowto); 738 739 if ((howto & RB_POWERDOWN) == RB_POWERDOWN) { 740 if (sys_platform->powerdown != NULL) 741 sys_platform->powerdown(); 742 } 743 744 if (howto & RB_HALT) { 745 printf("\n"); 746 printf("The operating system has halted.\n"); 747 printf("Please press any key to reboot.\n\n"); 748 cnpollc(1); /* For proper keyboard command handling */ 749 cngetc(); 750 cnpollc(0); 751 } 752 753 printf("%s\n\n", ((howto & RB_HALT) != 0) ? "halted." : "rebooting..."); 754 755 if (sys_platform->reset != NULL) 756 sys_platform->reset(); 757 758 __asm__ __volatile__ ( 759 "\t.long 0x3c02bfc0\n" 760 "\t.long 0x00400008\n" 761 ::: "v0"); 762 } 763 764 /* 765 * Early console through pmon routines. 766 */ 767 768 int 769 pmoncngetc(dev_t dev) 770 { 771 /* 772 * PMON does not give us a getc routine. So try to get a whole line 773 * and return it char by char, trying not to lose the \n. Kind 774 * of ugly but should work. 775 * 776 * Note that one could theoretically use pmon_read(STDIN, &c, 1) 777 * but the value of STDIN within PMON is not a constant and there 778 * does not seem to be a way of letting us know which value to use. 779 */ 780 static char buf[1 + PMON_MAXLN]; 781 static char *bufpos = buf; 782 int c; 783 784 if (*bufpos == '\0') { 785 bufpos = buf; 786 if (pmon_gets(buf) == NULL) { 787 /* either an empty line or EOF. assume the former */ 788 return (int)'\n'; 789 } else { 790 /* put back the \n sign */ 791 buf[strlen(buf)] = '\n'; 792 } 793 } 794 795 c = (int)*bufpos++; 796 if (bufpos - buf > PMON_MAXLN) { 797 bufpos = buf; 798 *bufpos = '\0'; 799 } 800 801 return c; 802 } 803 804 void 805 pmoncnputc(dev_t dev, int c) 806 { 807 if (c == '\n') 808 pmon_printf("\n"); 809 else 810 pmon_printf("%c", c); 811 } 812
Indexes created Thu Sep 25 15:09:46 GMT 2025