Annotation of sys/arch/aviion/aviion/machdep.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: machdep.c,v 1.10 2007/06/06 17:15:11 deraadt Exp $ */
! 2: /*
! 3: * Copyright (c) 1998, 1999, 2000, 2001 Steve Murphree, Jr.
! 4: * Copyright (c) 1996 Nivas Madhur
! 5: * All rights reserved.
! 6: *
! 7: * Redistribution and use in source and binary forms, with or without
! 8: * modification, are permitted provided that the following conditions
! 9: * are met:
! 10: * 1. Redistributions of source code must retain the above copyright
! 11: * notice, this list of conditions and the following disclaimer.
! 12: * 2. Redistributions in binary form must reproduce the above copyright
! 13: * notice, this list of conditions and the following disclaimer in the
! 14: * documentation and/or other materials provided with the distribution.
! 15: * 3. All advertising materials mentioning features or use of this software
! 16: * must display the following acknowledgement:
! 17: * This product includes software developed by Nivas Madhur.
! 18: * 4. The name of the author may not be used to endorse or promote products
! 19: * derived from this software without specific prior written permission
! 20: *
! 21: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 22: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 23: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 24: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 25: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 26: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 27: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 28: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 29: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 30: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 31: *
! 32: */
! 33: /*
! 34: * Mach Operating System
! 35: * Copyright (c) 1993-1991 Carnegie Mellon University
! 36: * Copyright (c) 1991 OMRON Corporation
! 37: * All Rights Reserved.
! 38: *
! 39: * Permission to use, copy, modify and distribute this software and its
! 40: * documentation is hereby granted, provided that both the copyright
! 41: * notice and this permission notice appear in all copies of the
! 42: * software, derivative works or modified versions, and any portions
! 43: * thereof, and that both notices appear in supporting documentation.
! 44: *
! 45: */
! 46:
! 47: #include <sys/param.h>
! 48: #include <sys/systm.h>
! 49: #include <sys/kernel.h>
! 50: #include <sys/proc.h>
! 51: #include <sys/user.h>
! 52: #include <sys/buf.h>
! 53: #include <sys/reboot.h>
! 54: #include <sys/conf.h>
! 55: #include <sys/malloc.h>
! 56: #include <sys/mount.h>
! 57: #include <sys/msgbuf.h>
! 58: #include <sys/syscallargs.h>
! 59: #ifdef SYSVMSG
! 60: #include <sys/msg.h>
! 61: #endif
! 62: #include <sys/exec.h>
! 63: #include <sys/sysctl.h>
! 64: #include <sys/errno.h>
! 65: #include <sys/extent.h>
! 66: #include <sys/core.h>
! 67: #include <sys/kcore.h>
! 68:
! 69: #include <machine/asm.h>
! 70: #include <machine/asm_macro.h>
! 71: #include <machine/autoconf.h>
! 72: #include <machine/board.h>
! 73: #include <machine/cmmu.h>
! 74: #include <machine/cpu.h>
! 75: #include <machine/kcore.h>
! 76: #include <machine/prom.h>
! 77: #include <machine/reg.h>
! 78: #include <machine/trap.h>
! 79:
! 80: #include <dev/cons.h>
! 81:
! 82: #include <uvm/uvm_extern.h>
! 83:
! 84: #include "ksyms.h"
! 85: #if DDB
! 86: #include <machine/db_machdep.h>
! 87: #include <ddb/db_extern.h>
! 88: #include <ddb/db_interface.h>
! 89: #include <ddb/db_var.h>
! 90: #endif /* DDB */
! 91:
! 92: caddr_t allocsys(caddr_t);
! 93: void aviion_bootstrap(void);
! 94: int aviion_identify(void);
! 95: void consinit(void);
! 96: __dead void doboot(void);
! 97: void dumpconf(void);
! 98: void dumpsys(void);
! 99: u_int getipl(void);
! 100: void identifycpu(void);
! 101: void savectx(struct pcb *);
! 102: void secondary_main(void);
! 103: void secondary_pre_main(void);
! 104:
! 105: intrhand_t intr_handlers[NVMEINTR];
! 106:
! 107: int physmem; /* available physical memory, in pages */
! 108:
! 109: struct vm_map *exec_map = NULL;
! 110: struct vm_map *phys_map = NULL;
! 111:
! 112: #ifdef MULTIPROCESSOR
! 113: __cpu_simple_lock_t cpu_mutex = __SIMPLELOCK_UNLOCKED;
! 114: #endif
! 115:
! 116: /*
! 117: * Declare these as initialized data so we can patch them.
! 118: */
! 119: #ifndef BUFCACHEPERCENT
! 120: #define BUFCACHEPERCENT 5
! 121: #endif
! 122:
! 123: #ifdef BUFPAGES
! 124: int bufpages = BUFPAGES;
! 125: #else
! 126: int bufpages = 0;
! 127: #endif
! 128: int bufcachepercent = BUFCACHEPERCENT;
! 129:
! 130: /*
! 131: * Info for CTL_HW
! 132: */
! 133: char machine[] = MACHINE; /* cpu "architecture" */
! 134: char cpu_model[120];
! 135:
! 136: #if defined(DDB) || NKSYMS > 0
! 137: extern vaddr_t esym;
! 138: #endif
! 139:
! 140: const char *prom_bootargs; /* set in locore.S */
! 141: char bootargs[256]; /* local copy */
! 142: u_int bootdev, bootunit, bootpart; /* set in locore.S */
! 143:
! 144: int cputyp; /* set in locore.S */
! 145: int cpuspeed = 20; /* safe guess */
! 146: int avtyp;
! 147: const struct board *platform;
! 148:
! 149: vaddr_t first_addr;
! 150: vaddr_t last_addr;
! 151:
! 152: vaddr_t avail_start, avail_end;
! 153: vaddr_t virtual_avail, virtual_end;
! 154:
! 155: extern struct user *proc0paddr;
! 156:
! 157: /*
! 158: * This is to fake out the console routines, while booting.
! 159: * We could use directly the bugtty console, but we want to be able to
! 160: * configure a kernel without bugtty since we do not necessarily need a
! 161: * full-blown console driver.
! 162: */
! 163: cons_decl(boot);
! 164:
! 165: struct consdev bootcons = {
! 166: NULL,
! 167: NULL,
! 168: bootcngetc,
! 169: bootcnputc,
! 170: nullcnpollc,
! 171: NULL,
! 172: makedev(14, 0),
! 173: CN_NORMAL
! 174: };
! 175:
! 176: /*
! 177: * Early console initialization: called early on from main, before vm init.
! 178: * We want to stick to the BUG routines for now, and we'll switch to the
! 179: * real console in cpu_startup().
! 180: */
! 181: void
! 182: consinit()
! 183: {
! 184: cn_tab = NULL;
! 185: cninit();
! 186:
! 187: #if defined(DDB)
! 188: db_machine_init();
! 189: ddb_init();
! 190: if (boothowto & RB_KDB)
! 191: Debugger();
! 192: #endif
! 193: }
! 194:
! 195: void
! 196: identifycpu()
! 197: {
! 198: #if 0
! 199: /* XXX FILL ME */
! 200: cpuspeed = getcpuspeed(&brdid);
! 201: #endif
! 202:
! 203: strlcpy(cpu_model, platform->descr, sizeof cpu_model);
! 204: }
! 205:
! 206: /*
! 207: * Set up real-time clocks.
! 208: * These function pointers are set in dev/clock.c.
! 209: */
! 210: void
! 211: cpu_initclocks()
! 212: {
! 213: platform->init_clocks();
! 214: }
! 215:
! 216: void
! 217: setstatclockrate(int newhz)
! 218: {
! 219: /* function stub */
! 220: }
! 221:
! 222:
! 223: void
! 224: cpu_startup()
! 225: {
! 226: caddr_t v;
! 227: int sz, i;
! 228: vsize_t size;
! 229: int base, residual;
! 230: vaddr_t minaddr, maxaddr;
! 231:
! 232: /*
! 233: * Initialize error message buffer (at end of core).
! 234: * avail_end was pre-decremented in aviion_bootstrap() to compensate.
! 235: */
! 236: for (i = 0; i < btoc(MSGBUFSIZE); i++)
! 237: pmap_kenter_pa((paddr_t)msgbufp + i * PAGE_SIZE,
! 238: avail_end + i * PAGE_SIZE, VM_PROT_READ | VM_PROT_WRITE);
! 239: pmap_update(pmap_kernel());
! 240: initmsgbuf((caddr_t)msgbufp, round_page(MSGBUFSIZE));
! 241:
! 242: /*
! 243: * Good {morning,afternoon,evening,night}.
! 244: */
! 245: printf(version);
! 246: identifycpu();
! 247: printf("real mem = %d\n", ctob(physmem));
! 248:
! 249: /*
! 250: * Find out how much space we need, allocate it,
! 251: * and then give everything true virtual addresses.
! 252: */
! 253: sz = (int)allocsys((caddr_t)0);
! 254:
! 255: if ((v = (caddr_t)uvm_km_zalloc(kernel_map, round_page(sz))) == 0)
! 256: panic("startup: no room for tables");
! 257: if (allocsys(v) - v != sz)
! 258: panic("startup: table size inconsistency");
! 259:
! 260: /*
! 261: * Grab machine dependent memory spaces
! 262: */
! 263: platform->startup();
! 264:
! 265: /*
! 266: * Determine how many buffers to allocate.
! 267: * We allocate bufcachepercent% of memory for buffer space.
! 268: */
! 269: if (bufpages == 0)
! 270: bufpages = physmem * bufcachepercent / 100;
! 271:
! 272: /* Restrict to at most 25% filled kvm */
! 273: if (bufpages >
! 274: (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) / PAGE_SIZE / 4)
! 275: bufpages = (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) /
! 276: PAGE_SIZE / 4;
! 277:
! 278: /*
! 279: * Allocate a submap for exec arguments. This map effectively
! 280: * limits the number of processes exec'ing at any time.
! 281: */
! 282: minaddr = vm_map_min(kernel_map);
! 283: exec_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
! 284: 16 * NCARGS, VM_MAP_PAGEABLE, FALSE, NULL);
! 285:
! 286: /*
! 287: * Allocate map for physio.
! 288: */
! 289: phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
! 290: VM_PHYS_SIZE, 0, FALSE, NULL);
! 291:
! 292: printf("avail mem = %ld (%d pages)\n", ptoa(uvmexp.free), uvmexp.free);
! 293:
! 294: /*
! 295: * Set up buffers, so they can be used to read disk labels.
! 296: */
! 297: bufinit();
! 298:
! 299: /*
! 300: * Set up interrupt handlers.
! 301: */
! 302: for (i = 0; i < NVMEINTR; i++)
! 303: SLIST_INIT(&intr_handlers[i]);
! 304:
! 305: /*
! 306: * Configure the system.
! 307: */
! 308: if (boothowto & RB_CONFIG) {
! 309: #ifdef BOOT_CONFIG
! 310: user_config();
! 311: #else
! 312: printf("kernel does not support -c; continuing..\n");
! 313: #endif
! 314: }
! 315: }
! 316:
! 317: /*
! 318: * Allocate space for system data structures. We are given
! 319: * a starting virtual address and we return a final virtual
! 320: * address; along the way we set each data structure pointer.
! 321: *
! 322: * We call allocsys() with 0 to find out how much space we want,
! 323: * allocate that much and fill it with zeroes, and then call
! 324: * allocsys() again with the correct base virtual address.
! 325: */
! 326: caddr_t
! 327: allocsys(v)
! 328: caddr_t v;
! 329: {
! 330:
! 331: #define valloc(name, type, num) \
! 332: v = (caddr_t)(((name) = (type *)v) + (num))
! 333:
! 334: #ifdef SYSVMSG
! 335: valloc(msgpool, char, msginfo.msgmax);
! 336: valloc(msgmaps, struct msgmap, msginfo.msgseg);
! 337: valloc(msghdrs, struct msg, msginfo.msgtql);
! 338: valloc(msqids, struct msqid_ds, msginfo.msgmni);
! 339: #endif
! 340:
! 341: return v;
! 342: }
! 343:
! 344: __dead void
! 345: doboot()
! 346: {
! 347: printf("Rebooting system...\n\n");
! 348: cmmu_shutdown();
! 349: scm_reboot(NULL);
! 350: /*NOTREACHED*/
! 351: for (;;); /* appease gcc */
! 352: }
! 353:
! 354: __dead void
! 355: boot(howto)
! 356: int howto;
! 357: {
! 358: /* take a snapshot before clobbering any registers */
! 359: if (curproc && curproc->p_addr)
! 360: savectx(curpcb);
! 361:
! 362: /* If system is cold, just halt. */
! 363: if (cold) {
! 364: /* (Unless the user explicitly asked for reboot.) */
! 365: if ((howto & RB_USERREQ) == 0)
! 366: howto |= RB_HALT;
! 367: goto haltsys;
! 368: }
! 369:
! 370: boothowto = howto;
! 371: if ((howto & RB_NOSYNC) == 0) {
! 372: vfs_shutdown();
! 373: /*
! 374: * If we've been adjusting the clock, the todr
! 375: * will be out of synch; adjust it now unless
! 376: * the system was sitting in ddb.
! 377: */
! 378: if ((howto & RB_TIMEBAD) == 0)
! 379: resettodr();
! 380: else
! 381: printf("WARNING: not updating battery clock\n");
! 382: }
! 383:
! 384: /* Disable interrupts. */
! 385: splhigh();
! 386:
! 387: /* If rebooting and a dump is requested, do it. */
! 388: if (howto & RB_DUMP)
! 389: dumpsys();
! 390:
! 391: haltsys:
! 392: /* Run any shutdown hooks. */
! 393: doshutdownhooks();
! 394:
! 395: if (howto & RB_HALT) {
! 396: printf("System halted.\n\n");
! 397: cmmu_shutdown();
! 398: scm_halt();
! 399: }
! 400:
! 401: doboot();
! 402:
! 403: for (;;);
! 404: /*NOTREACHED*/
! 405: }
! 406:
! 407: unsigned dumpmag = 0x8fca0101; /* magic number for savecore */
! 408: int dumpsize = 0; /* also for savecore */
! 409: long dumplo = 0;
! 410: cpu_kcore_hdr_t cpu_kcore_hdr;
! 411:
! 412: /*
! 413: * This is called by configure to set dumplo and dumpsize.
! 414: * Dumps always skip the first PAGE_SIZE of disk space
! 415: * in case there might be a disk label stored there.
! 416: * If there is extra space, put dump at the end to
! 417: * reduce the chance that swapping trashes it.
! 418: */
! 419: void
! 420: dumpconf(void)
! 421: {
! 422: int nblks; /* size of dump area */
! 423:
! 424: if (dumpdev == NODEV ||
! 425: (nblks = (bdevsw[major(dumpdev)].d_psize)(dumpdev)) == 0)
! 426: return;
! 427: if (nblks <= ctod(1))
! 428: return;
! 429:
! 430: dumpsize = physmem;
! 431:
! 432: /* aviion only uses a single segment. */
! 433: cpu_kcore_hdr.ram_segs[0].start = 0;
! 434: cpu_kcore_hdr.ram_segs[0].size = ctob(physmem);
! 435: cpu_kcore_hdr.cputype = cputyp;
! 436:
! 437: /*
! 438: * Don't dump on the first block
! 439: * in case the dump device includes a disk label.
! 440: */
! 441: if (dumplo < ctod(1))
! 442: dumplo = ctod(1);
! 443:
! 444: /* Put dump at end of partition, and make it fit. */
! 445: if (dumpsize + 1 > dtoc(nblks - dumplo))
! 446: dumpsize = dtoc(nblks - dumplo) - 1;
! 447: if (dumplo < nblks - ctod(dumpsize) - 1)
! 448: dumplo = nblks - ctod(dumpsize) - 1;
! 449: }
! 450:
! 451: /*
! 452: * Doadump comes here after turning off memory management and
! 453: * getting on the dump stack, either when called above, or by
! 454: * the auto-restart code.
! 455: */
! 456: void
! 457: dumpsys()
! 458: {
! 459: int maj;
! 460: int psize;
! 461: daddr64_t blkno; /* current block to write */
! 462: /* dump routine */
! 463: int (*dump)(dev_t, daddr64_t, caddr_t, size_t);
! 464: int pg; /* page being dumped */
! 465: paddr_t maddr; /* PA being dumped */
! 466: int error; /* error code from (*dump)() */
! 467: kcore_seg_t *kseg_p;
! 468: cpu_kcore_hdr_t *chdr_p;
! 469: char dump_hdr[dbtob(1)]; /* XXX assume hdr fits in 1 block */
! 470:
! 471: extern int msgbufmapped;
! 472:
! 473: msgbufmapped = 0;
! 474:
! 475: /* Make sure dump device is valid. */
! 476: if (dumpdev == NODEV)
! 477: return;
! 478: if (dumpsize == 0) {
! 479: dumpconf();
! 480: if (dumpsize == 0)
! 481: return;
! 482: }
! 483: maj = major(dumpdev);
! 484: if (dumplo < 0) {
! 485: printf("\ndump to dev %u,%u not possible\n", maj,
! 486: minor(dumpdev));
! 487: return;
! 488: }
! 489: dump = bdevsw[maj].d_dump;
! 490: blkno = dumplo;
! 491:
! 492: printf("\ndumping to dev %u,%u offset %ld\n", maj,
! 493: minor(dumpdev), dumplo);
! 494:
! 495: /* Setup the dump header */
! 496: kseg_p = (kcore_seg_t *)dump_hdr;
! 497: chdr_p = (cpu_kcore_hdr_t *)&dump_hdr[ALIGN(sizeof(*kseg_p))];
! 498: bzero(dump_hdr, sizeof(dump_hdr));
! 499:
! 500: CORE_SETMAGIC(*kseg_p, KCORE_MAGIC, MID_MACHINE, CORE_CPU);
! 501: kseg_p->c_size = dbtob(1) - ALIGN(sizeof(*kseg_p));
! 502: *chdr_p = cpu_kcore_hdr;
! 503:
! 504: printf("dump ");
! 505: psize = (*bdevsw[maj].d_psize)(dumpdev);
! 506: if (psize == -1) {
! 507: printf("area unavailable\n");
! 508: return;
! 509: }
! 510:
! 511: /* Dump the header. */
! 512: error = (*dump)(dumpdev, blkno++, (caddr_t)dump_hdr, dbtob(1));
! 513: if (error != 0)
! 514: goto abort;
! 515:
! 516: maddr = (paddr_t)0;
! 517: for (pg = 0; pg < dumpsize; pg++) {
! 518: #define NPGMB (1024 * 1024 / PAGE_SIZE)
! 519: /* print out how many MBs we have dumped */
! 520: if (pg != 0 && (pg % NPGMB) == 0)
! 521: printf("%d ", pg / NPGMB);
! 522: #undef NPGMB
! 523: pmap_enter(pmap_kernel(), (vaddr_t)vmmap, maddr,
! 524: VM_PROT_READ, VM_PROT_READ|PMAP_WIRED);
! 525:
! 526: error = (*dump)(dumpdev, blkno, vmmap, PAGE_SIZE);
! 527: if (error == 0) {
! 528: maddr += PAGE_SIZE;
! 529: blkno += btodb(PAGE_SIZE);
! 530: } else
! 531: break;
! 532: }
! 533: abort:
! 534: switch (error) {
! 535: case 0:
! 536: printf("succeeded\n");
! 537: break;
! 538:
! 539: case ENXIO:
! 540: printf("device bad\n");
! 541: break;
! 542:
! 543: case EFAULT:
! 544: printf("device not ready\n");
! 545: break;
! 546:
! 547: case EINVAL:
! 548: printf("area improper\n");
! 549: break;
! 550:
! 551: case EIO:
! 552: printf("i/o error\n");
! 553: break;
! 554:
! 555: case EINTR:
! 556: printf("aborted from console\n");
! 557: break;
! 558:
! 559: default:
! 560: printf("error %d\n", error);
! 561: break;
! 562: }
! 563: }
! 564:
! 565: #ifdef MULTIPROCESSOR
! 566:
! 567: /*
! 568: * Secondary CPU early initialization routine.
! 569: * Determine CPU number and set it, then allocate the idle pcb (and stack).
! 570: *
! 571: * Running on a minimal stack here, with interrupts disabled; do nothing fancy.
! 572: */
! 573: void
! 574: secondary_pre_main()
! 575: {
! 576: struct cpu_info *ci;
! 577:
! 578: set_cpu_number(cmmu_cpu_number()); /* Determine cpu number by CMMU */
! 579: ci = curcpu();
! 580: ci->ci_curproc = &proc0;
! 581:
! 582: splhigh();
! 583:
! 584: /*
! 585: * Setup CMMUs and translation tables (shared with the master cpu).
! 586: */
! 587: pmap_bootstrap_cpu(ci->ci_cpuid);
! 588:
! 589: /*
! 590: * Allocate UPAGES contiguous pages for the idle PCB and stack.
! 591: */
! 592: ci->ci_idle_pcb = (struct pcb *)uvm_km_zalloc(kernel_map, USPACE);
! 593: if (ci->ci_idle_pcb == NULL) {
! 594: printf("cpu%d: unable to allocate idle stack\n", ci->ci_cpuid);
! 595: }
! 596: }
! 597:
! 598: /*
! 599: * Further secondary CPU initialization.
! 600: *
! 601: * We are now running on our idle stack, with proper page tables.
! 602: * There is nothing to do but display some details about the CPU and its CMMUs.
! 603: */
! 604: void
! 605: secondary_main()
! 606: {
! 607: struct cpu_info *ci = curcpu();
! 608:
! 609: cpu_configuration_print(0);
! 610: ncpus++;
! 611: __cpu_simple_unlock(&cpu_mutex);
! 612:
! 613: microuptime(&ci->ci_schedstate.spc_runtime);
! 614: ci->ci_curproc = NULL;
! 615:
! 616: /*
! 617: * Upon return, the secondary cpu bootstrap code in locore will
! 618: * enter the idle loop, waiting for some food to process on this
! 619: * processor.
! 620: */
! 621: }
! 622:
! 623: #endif /* MULTIPROCESSOR */
! 624:
! 625: /*
! 626: * Try to insert ihand in the list of handlers for vector vec.
! 627: */
! 628: int
! 629: intr_establish(int vec, struct intrhand *ihand, const char *name)
! 630: {
! 631: struct intrhand *intr;
! 632: intrhand_t *list;
! 633:
! 634: if (vec < 0 || vec >= NVMEINTR) {
! 635: #ifdef DIAGNOSTIC
! 636: printf("intr_establish: vec (0x%x) not between 0x00 and 0xff\n",
! 637: vec);
! 638: #endif /* DIAGNOSTIC */
! 639: return (EINVAL);
! 640: }
! 641:
! 642: list = &intr_handlers[vec];
! 643: if (!SLIST_EMPTY(list)) {
! 644: intr = SLIST_FIRST(list);
! 645: if (intr->ih_ipl != ihand->ih_ipl) {
! 646: #ifdef DIAGNOSTIC
! 647: printf("intr_establish: there are other handlers with "
! 648: "vec (0x%x) at ipl %x, but you want it at %x\n",
! 649: vec, intr->ih_ipl, ihand->ih_ipl);
! 650: #endif /* DIAGNOSTIC */
! 651: return (EINVAL);
! 652: }
! 653: }
! 654:
! 655: evcount_attach(&ihand->ih_count, name, (void *)&ihand->ih_ipl,
! 656: &evcount_intr);
! 657: SLIST_INSERT_HEAD(list, ihand, ih_link);
! 658: return (0);
! 659: }
! 660:
! 661: void
! 662: nmihand(void *frame)
! 663: {
! 664: #ifdef DDB
! 665: printf("Abort switch pressed\n");
! 666: if (db_console) {
! 667: /*
! 668: * We can't use Debugger() here, as we are coming from an
! 669: * exception, and can't assume anything on the state we are
! 670: * in. Invoke the post-trap ddb entry directly.
! 671: */
! 672: extern void m88k_db_trap(int, struct trapframe *);
! 673: m88k_db_trap(T_KDB_ENTRY, (struct trapframe *)frame);
! 674: }
! 675: #endif
! 676: }
! 677:
! 678: int
! 679: cpu_exec_aout_makecmds(p, epp)
! 680: struct proc *p;
! 681: struct exec_package *epp;
! 682: {
! 683:
! 684: return (ENOEXEC);
! 685: }
! 686:
! 687: int
! 688: sys_sysarch(p, v, retval)
! 689: struct proc *p;
! 690: void *v;
! 691: register_t *retval;
! 692: {
! 693: #if 0
! 694: struct sys_sysarch_args /* {
! 695: syscallarg(int) op;
! 696: syscallarg(char *) parm;
! 697: } */ *uap = v;
! 698: #endif
! 699:
! 700: return (ENOSYS);
! 701: }
! 702:
! 703: /*
! 704: * machine dependent system variables.
! 705: */
! 706:
! 707: int
! 708: cpu_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
! 709: int *name;
! 710: u_int namelen;
! 711: void *oldp;
! 712: size_t *oldlenp;
! 713: void *newp;
! 714: size_t newlen;
! 715: struct proc *p;
! 716: {
! 717: dev_t consdev;
! 718:
! 719: /* all sysctl names are this level are terminal */
! 720: if (namelen != 1)
! 721: return (ENOTDIR); /* overloaded */
! 722:
! 723: switch (name[0]) {
! 724: case CPU_CONSDEV:
! 725: if (cn_tab != NULL)
! 726: consdev = cn_tab->cn_dev;
! 727: else
! 728: consdev = NODEV;
! 729: return (sysctl_rdstruct(oldp, oldlenp, newp, &consdev,
! 730: sizeof consdev));
! 731: default:
! 732: return (EOPNOTSUPP);
! 733: }
! 734: /*NOTREACHED*/
! 735: }
! 736:
! 737: /*
! 738: * Called from locore.S during boot,
! 739: * this is the first C code that's run.
! 740: */
! 741: void
! 742: aviion_bootstrap()
! 743: {
! 744: extern int kernelstart;
! 745: extern char *end;
! 746: #ifndef MULTIPROCESSOR
! 747: cpuid_t master_cpu;
! 748: #endif
! 749:
! 750: /* Save a copy of our commandline before it gets overwritten. */
! 751: strlcpy(bootargs, prom_bootargs, sizeof bootargs);
! 752:
! 753: avtyp = aviion_identify();
! 754:
! 755: /* Set up interrupt and fp exception handlers based on the machine. */
! 756: switch (avtyp) {
! 757: #ifdef AV400
! 758: case AV_400:
! 759: platform = &board_av400;
! 760: break;
! 761: #endif
! 762: #ifdef AV530
! 763: case AV_530:
! 764: platform = &board_av530;
! 765: break;
! 766: #endif
! 767: #ifdef AV5000
! 768: case AV_5000:
! 769: platform = &board_av5000;
! 770: break;
! 771: #endif
! 772: #ifdef AV6280
! 773: case AV_6280:
! 774: platform = &board_av6280;
! 775: break;
! 776: #endif
! 777: default:
! 778: scm_printf("Sorry, OpenBSD/" MACHINE
! 779: " does not support this model.\n");
! 780: scm_halt();
! 781: break;
! 782: };
! 783:
! 784: cn_tab = &bootcons;
! 785: /* we can use printf() from here. */
! 786:
! 787: platform->bootstrap();
! 788:
! 789: /* Parse the commandline */
! 790: cmdline_parse();
! 791:
! 792: uvmexp.pagesize = PAGE_SIZE;
! 793: uvm_setpagesize();
! 794:
! 795: #if defined(DDB) || NKSYMS > 0
! 796: if (esym != 0)
! 797: first_addr = esym;
! 798: else
! 799: #endif
! 800: first_addr = (vaddr_t)&end;
! 801: first_addr = round_page(first_addr);
! 802:
! 803: last_addr = platform->memsize();
! 804: physmem = btoc(last_addr);
! 805:
! 806: setup_board_config();
! 807: master_cpu = cmmu_init();
! 808: set_cpu_number(master_cpu);
! 809:
! 810: /*
! 811: * Now that set_cpu_number() set us with a valid cpu_info pointer,
! 812: * we need to initialize p_addr and curpcb before autoconf, for the
! 813: * fault handler to behave properly [except for badaddr() faults,
! 814: * which can be taken care of without a valid curcpu()].
! 815: */
! 816: proc0.p_addr = proc0paddr;
! 817: curproc = &proc0;
! 818: curpcb = &proc0paddr->u_pcb;
! 819:
! 820: avail_start = round_page(first_addr);
! 821: avail_end = last_addr;
! 822:
! 823: /* Steal MSGBUFSIZE at the top of physical memory for msgbuf. */
! 824: avail_end -= round_page(MSGBUFSIZE);
! 825: pmap_bootstrap((vaddr_t)trunc_page((unsigned)&kernelstart));
! 826:
! 827: /*
! 828: * Tell the VM system about available physical memory.
! 829: * The aviion systems only have one contiguous area.
! 830: *
! 831: * XXX However, on series 5000, SRAM overlaps a low memory range,
! 832: * XXX so we will need to upload two ranges of pages on them.
! 833: */
! 834: uvm_page_physload(atop(avail_start), atop(avail_end),
! 835: atop(avail_start), atop(avail_end), VM_FREELIST_DEFAULT);
! 836:
! 837: /* Initialize the "u-area" pages. */
! 838: bzero((caddr_t)curpcb, USPACE);
! 839: }
! 840:
! 841: #ifdef MULTIPROCESSOR
! 842: void
! 843: cpu_boot_secondary_processors()
! 844: {
! 845: cpuid_t cpu;
! 846: int rc;
! 847: extern void secondary_start(void);
! 848:
! 849: for (cpu = 0; cpu < max_cpus; cpu++) {
! 850: if (cpu != curcpu()->ci_cpuid) {
! 851: rc = scm_spincpu(cpu, (vaddr_t)secondary_start);
! 852: if (rc != 0)
! 853: printf("cpu%d: spin_cpu error %d\n", cpu, rc);
! 854: }
! 855: }
! 856: }
! 857: #endif
! 858:
! 859: /*
! 860: * Boot console routines:
! 861: * Enables printing of boot messages before consinit().
! 862: */
! 863: void
! 864: bootcnprobe(cp)
! 865: struct consdev *cp;
! 866: {
! 867: cp->cn_dev = makedev(0, 0);
! 868: cp->cn_pri = CN_NORMAL;
! 869: }
! 870:
! 871: void
! 872: bootcninit(cp)
! 873: struct consdev *cp;
! 874: {
! 875: /* Nothing to do */
! 876: }
! 877:
! 878: int
! 879: bootcngetc(dev)
! 880: dev_t dev;
! 881: {
! 882: return (scm_getc());
! 883: }
! 884:
! 885: void
! 886: bootcnputc(dev, c)
! 887: dev_t dev;
! 888: int c;
! 889: {
! 890: if (c == '\n')
! 891: scm_putcrlf();
! 892: else
! 893: scm_putc(c);
! 894: }
! 895:
! 896: u_int
! 897: getipl(void)
! 898: {
! 899: u_int curspl, psr;
! 900:
! 901: disable_interrupt(psr);
! 902: curspl = platform->getipl();
! 903: set_psr(psr);
! 904: return curspl;
! 905: }
! 906:
! 907: u_int
! 908: setipl(u_int level)
! 909: {
! 910: u_int curspl, psr;
! 911:
! 912: disable_interrupt(psr);
! 913: curspl = platform->setipl(level);
! 914:
! 915: /*
! 916: * The flush pipeline is required to make sure the above change gets
! 917: * through the data pipe and to the hardware; otherwise, the next
! 918: * bunch of instructions could execute at the wrong spl protection.
! 919: */
! 920: flush_pipeline();
! 921:
! 922: set_psr(psr);
! 923: return curspl;
! 924: }
! 925:
! 926: u_int
! 927: raiseipl(u_int level)
! 928: {
! 929: u_int curspl, psr;
! 930:
! 931: disable_interrupt(psr);
! 932: curspl = platform->raiseipl(level);
! 933:
! 934: /*
! 935: * The flush pipeline is required to make sure the above change gets
! 936: * through the data pipe and to the hardware; otherwise, the next
! 937: * bunch of instructions could execute at the wrong spl protection.
! 938: */
! 939: flush_pipeline();
! 940:
! 941: set_psr(psr);
! 942: return curspl;
! 943: }
! 944:
! 945: u_char hostaddr[6];
! 946:
! 947: void
! 948: myetheraddr(u_char *cp)
! 949: {
! 950: bcopy(hostaddr, cp, 6);
! 951: }
! 952:
! 953: /*
! 954: * Attempt to identify which AViiON flavour we are running on.
! 955: * The only thing we can do at this point is peek at random addresses and
! 956: * see if they cause bus errors, or not.
! 957: *
! 958: * These heuristics are probably not the best; feel free to come with better
! 959: * ones...
! 960: */
! 961: int
! 962: aviion_identify()
! 963: {
! 964: /*
! 965: * We don't know anything about 88110-based models.
! 966: * Note that we can't use CPU_IS81x0 here since these are optimized
! 967: * if the kernel you're running is compiled for only one processor
! 968: * type, and we want to check against the real hardware.
! 969: */
! 970: if (cputyp == CPU_88110)
! 971: return (0);
! 972:
! 973: /*
! 974: * Series 100/200/300/400/3000/4000/4300 do not have the VIRQLV
! 975: * register at 0xfff85000.
! 976: */
! 977: if (badaddr(0xfff85000, 4) != 0)
! 978: return (AV_400);
! 979:
! 980: /*
! 981: * Series 5000 and 6000 do not have an RTC counter at 0xfff8f084.
! 982: */
! 983: if (badaddr(0xfff8f084, 4) != 0)
! 984: return (AV_5000);
! 985:
! 986: /*
! 987: * Series 4600/530 have IOFUSEs at 0xfffb0040 and 0xfffb00c0.
! 988: */
! 989: if (badaddr(0xfffb0040, 1) == 0 && badaddr(0xfffb00c0, 1) == 0)
! 990: return (AV_530);
! 991:
! 992: /*
! 993: * Series 6280/8000-8 fall here.
! 994: */
! 995: return (AV_6280);
! 996: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to machdep.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / aviion / aviion