Annotation of sys/arch/mvmeppc/mvmeppc/machdep.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: machdep.c,v 1.53 2007/05/26 20:26:51 pedro Exp $ */
! 2: /* $NetBSD: machdep.c,v 1.4 1996/10/16 19:33:11 ws Exp $ */
! 3:
! 4: /*
! 5: * Copyright (C) 1995, 1996 Wolfgang Solfrank.
! 6: * Copyright (C) 1995, 1996 TooLs GmbH.
! 7: * All rights reserved.
! 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 by TooLs GmbH.
! 20: * 4. The name of TooLs GmbH may not be used to endorse or promote products
! 21: * derived from this software without specific prior written permission.
! 22: *
! 23: * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
! 24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 25: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 26: * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
! 27: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
! 28: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
! 29: * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
! 30: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
! 31: * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
! 32: * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 33: */
! 34:
! 35: #include <sys/param.h>
! 36: #include <sys/buf.h>
! 37: #include <sys/timeout.h>
! 38: #include <sys/exec.h>
! 39: #include <sys/malloc.h>
! 40: #include <sys/mbuf.h>
! 41: #include <sys/mount.h>
! 42: #include <sys/msgbuf.h>
! 43: #include <sys/proc.h>
! 44: #include <sys/signalvar.h>
! 45: #include <sys/reboot.h>
! 46: #include <sys/syscallargs.h>
! 47: #ifdef SYSVMSG
! 48: #include <sys/msg.h>
! 49: #endif
! 50: #include <sys/syslog.h>
! 51: #include <sys/extent.h>
! 52: #include <sys/systm.h>
! 53: #include <sys/user.h>
! 54:
! 55: #include <net/netisr.h>
! 56:
! 57: #include <machine/bat.h>
! 58: #include <machine/bugio.h>
! 59: #include <machine/pmap.h>
! 60: #include <machine/powerpc.h>
! 61: #include <machine/trap.h>
! 62: #include <machine/autoconf.h>
! 63: #include <machine/bus.h>
! 64: #include <machine/conf.h>
! 65: #include <machine/pio.h>
! 66: #include <machine/prom.h>
! 67:
! 68: #include <dev/cons.h>
! 69:
! 70: #include <uvm/uvm_extern.h>
! 71:
! 72: #ifdef DDB
! 73: #include <machine/db_machdep.h>
! 74: #include <ddb/db_access.h>
! 75: #include <ddb/db_sym.h>
! 76: #include <ddb/db_extern.h>
! 77: #endif
! 78:
! 79: void initppc(u_int, u_int, char *);
! 80: void dumpsys(void);
! 81: int lcsplx(int);
! 82: void myetheraddr(u_char *);
! 83:
! 84: /*
! 85: * Global variables used here and there
! 86: */
! 87: struct pcb *curpcb;
! 88: struct pmap *curpm;
! 89: struct proc *fpuproc;
! 90:
! 91: extern struct user *proc0paddr;
! 92:
! 93: /*
! 94: * This is to fake out the console routines, while booting.
! 95: */
! 96: cons_decl(boot);
! 97: #define bootcnpollc nullcnpollc
! 98:
! 99: static struct consdev bootcons = {
! 100: NULL,
! 101: NULL,
! 102: bootcngetc,
! 103: bootcnputc,
! 104: bootcnpollc,
! 105: NULL,
! 106: makedev(14, 0),
! 107: CN_NORMAL,
! 108: };
! 109:
! 110: /*
! 111: * Declare these as initialized data so we can patch them.
! 112: */
! 113: #ifndef BUFCACHEPERCENT
! 114: #define BUFCACHEPERCENT 5
! 115: #endif
! 116:
! 117: #ifdef BUFPAGES
! 118: int bufpages = BUFPAGES;
! 119: #else
! 120: int bufpages = 0;
! 121: #endif
! 122: int bufcachepercent = BUFCACHEPERCENT;
! 123:
! 124: struct bat battable[16];
! 125:
! 126: struct vm_map *exec_map = NULL;
! 127: struct vm_map *phys_map = NULL;
! 128:
! 129: int ppc_malloc_ok;
! 130:
! 131: #ifndef SYS_TYPE
! 132: /* XXX Hardwire it for now */
! 133: #define SYS_TYPE MVME
! 134: #endif
! 135:
! 136: int system_type = SYS_TYPE; /* XXX Hardwire it for now */
! 137:
! 138: struct firmware *fw = NULL;
! 139: extern struct firmware ppc1_firmware;
! 140:
! 141: caddr_t allocsys(caddr_t);
! 142:
! 143: /*
! 144: * Extent maps to manage I/O. Allocate storage for 8 regions in each,
! 145: * initially. Later devio_malloc_safe will indicate that it's safe to
! 146: * use malloc() to dynamically allocate region descriptors.
! 147: */
! 148: static long devio_ex_storage[EXTENT_FIXED_STORAGE_SIZE(8) / sizeof (long)];
! 149: struct extent *devio_ex;
! 150: static int devio_malloc_safe = 0;
! 151:
! 152: void
! 153: initppc(startkernel, endkernel, args)
! 154: u_int startkernel, endkernel;
! 155: char *args;
! 156: {
! 157: extern void *trapcode; extern int trapsize;
! 158: extern void *dsitrap; extern int dsisize;
! 159: extern void *isitrap; extern int isisize;
! 160: extern void *alitrap; extern int alisize;
! 161: extern void *decrint; extern int decrsize;
! 162: extern void *tlbimiss; extern int tlbimsize;
! 163: extern void *tlbdlmiss; extern int tlbdlmsize;
! 164: extern void *tlbdsmiss; extern int tlbdsmsize;
! 165: #ifdef DDB
! 166: extern void *ddblow; extern int ddbsize;
! 167: #endif
! 168: extern void consinit(void);
! 169: extern void *msgbuf_addr;
! 170: int exc, scratch;
! 171:
! 172: proc0.p_addr = proc0paddr;
! 173: bzero(proc0.p_addr, sizeof *proc0.p_addr);
! 174:
! 175: fw = &ppc1_firmware; /* Just PPC1-Bug for now... */
! 176: buginit();
! 177:
! 178: curpcb = &proc0paddr->u_pcb;
! 179:
! 180: curpm = curpcb->pcb_pmreal = curpcb->pcb_pm = pmap_kernel();
! 181:
! 182: /* startup fake console driver. It will be replaced by consinit() */
! 183: cn_tab = &bootcons;
! 184:
! 185: /*
! 186: * Initialize BAT registers to unmapped to not generate
! 187: * overlapping mappings below.
! 188: */
! 189: ppc_mtibat0u(0);
! 190: ppc_mtibat1u(0);
! 191: ppc_mtibat2u(0);
! 192: ppc_mtibat3u(0);
! 193: ppc_mtdbat0u(0);
! 194: ppc_mtdbat1u(0);
! 195: ppc_mtdbat2u(0);
! 196: ppc_mtdbat3u(0);
! 197:
! 198: /*
! 199: * Set up initial BAT table
! 200: */
! 201: battable[0].batl = BATL(0x00000000, BAT_M);
! 202: battable[0].batu = BATU(0x00000000);
! 203:
! 204: /*
! 205: * Now setup fixed bat registers
! 206: *
! 207: * Note that we still run in real mode, and the BAT
! 208: * registers were cleared above.
! 209: */
! 210: /* IBAT0 used for initial 256 MB segment */
! 211: ppc_mtibat0l(battable[0].batl);
! 212: ppc_mtibat0u(battable[0].batu);
! 213:
! 214: /* DBAT0 used similar */
! 215: ppc_mtdbat0l(battable[0].batl);
! 216: ppc_mtdbat0u(battable[0].batu);
! 217:
! 218: /*
! 219: * Set up trap vectors
! 220: */
! 221: for (exc = EXC_RSVD; exc <= EXC_LAST; exc += 0x100) {
! 222: switch (exc) {
! 223: default:
! 224: bcopy(&trapcode, (void *)exc, (size_t)&trapsize);
! 225: break;
! 226: case EXC_EXI:
! 227: /*
! 228: * This one is (potentially) installed during autoconf
! 229: */
! 230: break;
! 231:
! 232: case EXC_DSI:
! 233: bcopy(&dsitrap, (void *)exc, (size_t)&dsisize);
! 234: break;
! 235: case EXC_ISI:
! 236: bcopy(&isitrap, (void *)exc, (size_t)&isisize);
! 237: break;
! 238: case EXC_ALI:
! 239: bcopy(&alitrap, (void *)exc, (size_t)&alisize);
! 240: break;
! 241: case EXC_DECR:
! 242: bcopy(&decrint, (void *)exc, (size_t)&decrsize);
! 243: break;
! 244: case EXC_IMISS:
! 245: bcopy(&tlbimiss, (void *)exc, (size_t)&tlbimsize);
! 246: break;
! 247: case EXC_DLMISS:
! 248: bcopy(&tlbdlmiss, (void *)exc, (size_t)&tlbdlmsize);
! 249: break;
! 250: case EXC_DSMISS:
! 251: bcopy(&tlbdsmiss, (void *)exc, (size_t)&tlbdsmsize);
! 252: break;
! 253: #ifdef DDB
! 254: case EXC_PGM:
! 255: case EXC_TRC:
! 256: case EXC_BPT:
! 257: bcopy(&ddblow, (void *)exc, (size_t)&ddbsize);
! 258: break;
! 259: #endif
! 260: }
! 261: }
! 262:
! 263: /* Grr, ALTIVEC_UNAVAIL is a vector not ~0xff aligned: 0x0f20 */
! 264: bcopy(&trapcode, (void *)0xf20, (size_t)&trapsize);
! 265:
! 266: /*
! 267: * since trapsize is > 0x20, we just overwrote the EXC_PERF handler
! 268: * since we do not use it, we will "share" it with the EXC_VEC,
! 269: * we dont support EXC_VEC either.
! 270: * should be a 'ba 0xf20 written' at address 0xf00, but we
! 271: * do not generate EXC_PERF exceptions...
! 272: */
! 273:
! 274: syncicache((void *)EXC_RST, EXC_LAST - EXC_RST + 0x100);
! 275:
! 276: /*
! 277: * Initialize pmap module.
! 278: */
! 279: uvmexp.pagesize = 4096;
! 280: uvm_setpagesize();
! 281: pmap_bootstrap(startkernel, endkernel);
! 282:
! 283: #if 1
! 284: /* MVME2[67]00 max out at 256MB, and we need BAT2 for now. */
! 285: #else
! 286: /* use BATs to map 1GB memory, no pageable BATs now */
! 287: if (physmem > btoc(0x10000000)) {
! 288: ppc_mtdbat1l(BATL(0x10000000, BAT_M));
! 289: ppc_mtdbat1u(BATU(0x10000000));
! 290: }
! 291: if (physmem > btoc(0x20000000)) {
! 292: ppc_mtdbat2l(BATL(0x20000000, BAT_M));
! 293: ppc_mtdbat2u(BATU(0x20000000));
! 294: }
! 295: if (physmem > btoc(0x30000000)) {
! 296: ppc_mtdbat3l(BATL(0x30000000, BAT_M));
! 297: ppc_mtdbat3u(BATU(0x30000000));
! 298: }
! 299: #endif
! 300:
! 301: /*
! 302: * Now enable translation (and machine checks/recoverable interrupts).
! 303: * This will also start using the exception vector prefix of 0x000.
! 304: */
! 305: (fw->vmon)();
! 306:
! 307: __asm__ volatile ("eieio; mfmsr %0; ori %0,%0,%1; mtmsr %0; sync;isync"
! 308: : "=r"(scratch) : "K"(PSL_IR|PSL_DR|PSL_ME|PSL_RI));
! 309:
! 310: /*
! 311: * use the memory provided by pmap_bootstrap for message buffer
! 312: */
! 313: initmsgbuf(msgbuf_addr, MSGBUFSIZE);
! 314:
! 315: #ifdef DDB
! 316: #ifdef notyet
! 317: db_machine_init();
! 318: #endif
! 319: ddb_init();
! 320: #endif
! 321:
! 322: /*
! 323: * Set up extents for pci mappings
! 324: * Is this too late?
! 325: *
! 326: * what are good start and end values here??
! 327: * 0x0 - 0x80000000 mcu bus
! 328: * MAP A MAP B
! 329: * 0x80000000 - 0xbfffffff io 0x80000000 - 0xefffffff mem
! 330: * 0xc0000000 - 0xffffffff mem 0xf0000000 - 0xffffffff io
! 331: *
! 332: * of course bsd uses 0xe and 0xf
! 333: * So the BSD PPC memory map will look like this
! 334: * 0x0 - 0x80000000 memory (whatever is filled)
! 335: * 0x80000000 - 0xdfffffff (pci space, memory or io)
! 336: * 0xe0000000 - kernel vm segment
! 337: * 0xf0000000 - kernel map segment (user space mapped here)
! 338: */
! 339:
! 340: devio_ex = extent_create("devio", 0x80000000, 0xffffffff, M_DEVBUF,
! 341: (caddr_t)devio_ex_storage, sizeof(devio_ex_storage),
! 342: EX_NOCOALESCE|EX_NOWAIT);
! 343:
! 344: /*
! 345: * Now we can set up the console as mapping is enabled.
! 346: */
! 347: consinit();
! 348:
! 349: if (boothowto & RB_CONFIG) {
! 350: #ifdef BOOT_CONFIG
! 351: user_config();
! 352: #else
! 353: printf("kernel does not support -c; continuing..\n");
! 354: #endif
! 355: }
! 356:
! 357: #ifdef DDB
! 358: if (boothowto & RB_KDB)
! 359: Debugger();
! 360: #endif
! 361: }
! 362:
! 363: void
! 364: install_extint(handler)
! 365: void (*handler)(void);
! 366: {
! 367: extern caddr_t extint, extsize;
! 368: extern u_long extint_call;
! 369: u_long offset = (u_long)handler - (u_long)&extint_call;
! 370: int msr;
! 371:
! 372: #ifdef DIAGNOSTIC
! 373: if (offset > 0x1ffffff)
! 374: panic("install_extint: too far away");
! 375: #endif
! 376: msr = ppc_intr_disable();
! 377: extint_call = (extint_call & 0xfc000003) | offset;
! 378: bcopy(&extint, (void *)EXC_EXI, (size_t)&extsize);
! 379: syncicache((void *)&extint_call, sizeof extint_call);
! 380: syncicache((void *)EXC_EXI, (int)&extsize);
! 381: ppc_intr_enable(msr);
! 382: }
! 383:
! 384: /*
! 385: * Machine dependent startup code.
! 386: */
! 387: void
! 388: cpu_startup()
! 389: {
! 390: int sz;
! 391: caddr_t v;
! 392: vaddr_t minaddr, maxaddr;
! 393:
! 394: proc0.p_addr = proc0paddr;
! 395:
! 396: printf("%s", version);
! 397:
! 398: printf("real mem = %u (%uMB)\n", ctob(physmem),
! 399: ctob(physmem)/1024/1024);
! 400:
! 401: /*
! 402: * Find out how much space we need, allocate it,
! 403: * and then give everything true virtual addresses.
! 404: */
! 405: sz = (int)allocsys((caddr_t)0);
! 406: if ((v = (caddr_t)uvm_km_zalloc(kernel_map, round_page(sz))) == 0)
! 407: panic("startup: no room for tables");
! 408: if (allocsys(v) - v != sz)
! 409: panic("startup: table size inconsistency");
! 410:
! 411: /*
! 412: * Determine how many buffers to allocate.
! 413: * We allocate bufcachepercent% of memory for buffer space.
! 414: */
! 415: if (bufpages == 0)
! 416: bufpages = physmem * bufcachepercent / 100;
! 417:
! 418: /* Restrict to at most 25% filled kvm */
! 419: if (bufpages >
! 420: (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) / PAGE_SIZE / 4)
! 421: bufpages = (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) /
! 422: PAGE_SIZE / 4;
! 423:
! 424: /*
! 425: * Allocate a submap for exec arguments. This map effectively
! 426: * limits the number of processes exec'ing at any time.
! 427: */
! 428: minaddr = vm_map_min(kernel_map);
! 429: exec_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr, 16 * NCARGS,
! 430: VM_MAP_PAGEABLE, FALSE, NULL);
! 431:
! 432: /*
! 433: * Allocate a submap for physio
! 434: */
! 435: phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
! 436: VM_PHYS_SIZE, 0, FALSE, NULL);
! 437: ppc_malloc_ok = 1;
! 438:
! 439: printf("avail mem = %lu (%luMB)\n", ptoa(uvmexp.free),
! 440: ptoa(uvmexp.free) / 1024 / 1024);
! 441:
! 442: /*
! 443: * Set up the buffers.
! 444: */
! 445: bufinit();
! 446:
! 447: /*
! 448: * Set up early mappings
! 449: */
! 450: devio_malloc_safe = 1;
! 451: nvram_map();
! 452: prep_bus_space_init();
! 453: }
! 454:
! 455: /*
! 456: * Allocate space for system data structures.
! 457: */
! 458: caddr_t
! 459: allocsys(v)
! 460: caddr_t v;
! 461: {
! 462: #define valloc(name, type, num) \
! 463: v = (caddr_t)(((name) = (type *)v) + (num))
! 464:
! 465: #ifdef SYSVMSG
! 466: valloc(msgpool, char, msginfo.msgmax);
! 467: valloc(msgmaps, struct msgmap, msginfo.msgseg);
! 468: valloc(msghdrs, struct msg, msginfo.msgtql);
! 469: valloc(msqids, struct msqid_ds, msginfo.msgmni);
! 470: #endif
! 471:
! 472: return v;
! 473: }
! 474:
! 475: /*
! 476: * consinit
! 477: * Initialize system console.
! 478: */
! 479: void
! 480: consinit()
! 481: {
! 482: static int cons_initted = 0;
! 483:
! 484: if (cons_initted)
! 485: return;
! 486: cn_tab = NULL;
! 487: cninit();
! 488: cons_initted = 1;
! 489: }
! 490:
! 491: /*
! 492: * Clear registers on exec
! 493: */
! 494: void
! 495: setregs(p, pack, stack, retval)
! 496: struct proc *p;
! 497: struct exec_package *pack;
! 498: u_long stack;
! 499: register_t *retval;
! 500: {
! 501: u_int32_t newstack;
! 502: u_int32_t pargs;
! 503: u_int32_t args[4];
! 504:
! 505: struct trapframe *tf = trapframe(p);
! 506: pargs = -roundup(-stack + 8, 16);
! 507: newstack = (u_int32_t)(pargs - 32);
! 508:
! 509: copyin ((void *)(VM_MAX_ADDRESS-0x10), &args, 0x10);
! 510:
! 511: bzero(tf, sizeof *tf);
! 512: tf->fixreg[1] = newstack;
! 513: tf->fixreg[3] = retval[0] = args[1]; /* XXX */
! 514: tf->fixreg[4] = retval[1] = args[0]; /* XXX */
! 515: tf->fixreg[5] = args[2]; /* XXX */
! 516: tf->fixreg[6] = args[3]; /* XXX */
! 517: tf->srr0 = pack->ep_entry;
! 518: tf->srr1 = PSL_MBO | PSL_USERSET | PSL_FE_DFLT;
! 519: p->p_addr->u_pcb.pcb_flags = 0;
! 520: }
! 521:
! 522: /*
! 523: * Send a signal to process.
! 524: */
! 525: void
! 526: sendsig(catcher, sig, mask, code, type, val)
! 527: sig_t catcher;
! 528: int sig, mask;
! 529: u_long code;
! 530: int type;
! 531: union sigval val;
! 532: {
! 533: struct proc *p = curproc;
! 534: struct trapframe *tf;
! 535: struct sigframe *fp, frame;
! 536: struct sigacts *psp = p->p_sigacts;
! 537: int oldonstack;
! 538:
! 539: frame.sf_signum = sig;
! 540:
! 541: tf = trapframe(p);
! 542: oldonstack = psp->ps_sigstk.ss_flags & SS_ONSTACK;
! 543:
! 544: /*
! 545: * Allocate stack space for signal handler.
! 546: */
! 547: if ((psp->ps_flags & SAS_ALTSTACK)
! 548: && !oldonstack
! 549: && (psp->ps_sigonstack & sigmask(sig))) {
! 550: fp = (struct sigframe *)(psp->ps_sigstk.ss_sp
! 551: + psp->ps_sigstk.ss_size);
! 552: psp->ps_sigstk.ss_flags |= SS_ONSTACK;
! 553: } else
! 554: fp = (struct sigframe *)tf->fixreg[1];
! 555:
! 556: fp = (struct sigframe *)((int)(fp - 1) & ~0xf);
! 557:
! 558: /*
! 559: * Generate signal context for SYS_sigreturn.
! 560: */
! 561: frame.sf_sc.sc_onstack = oldonstack;
! 562: frame.sf_sc.sc_mask = mask;
! 563: frame.sf_sip = NULL;
! 564: bcopy(tf, &frame.sf_sc.sc_frame, sizeof *tf);
! 565: if (psp->ps_siginfo & sigmask(sig)) {
! 566: frame.sf_sip = &fp->sf_si;
! 567: initsiginfo(&frame.sf_si, sig, code, type, val);
! 568: }
! 569: if (copyout(&frame, fp, sizeof frame) != 0)
! 570: sigexit(p, SIGILL);
! 571:
! 572:
! 573: tf->fixreg[1] = (int)fp;
! 574: tf->lr = (int)catcher;
! 575: tf->fixreg[3] = (int)sig;
! 576: tf->fixreg[4] = (psp->ps_siginfo & sigmask(sig)) ? (int)&fp->sf_si : 0;
! 577: tf->fixreg[5] = (int)&fp->sf_sc;
! 578: tf->srr0 = p->p_sigcode;
! 579:
! 580: #if WHEN_WE_ONLY_FLUSH_DATA_WHEN_DOING_PMAP_ENTER
! 581: pmap_extract(vm_map_pmap(&p->p_vmspace->vm_map),tf->srr0, &pa);
! 582: syncicache(pa, (p->p_emul->e_esigcode - p->p_emul->e_sigcode));
! 583: #endif
! 584: }
! 585:
! 586: /*
! 587: * System call to cleanup state after a signal handler returns.
! 588: */
! 589: int
! 590: sys_sigreturn(p, v, retval)
! 591: struct proc *p;
! 592: void *v;
! 593: register_t *retval;
! 594: {
! 595: struct sys_sigreturn_args /* {
! 596: syscallarg(struct sigcontext *) sigcntxp;
! 597: } */ *uap = v;
! 598: struct sigcontext sc;
! 599: struct trapframe *tf;
! 600: int error;
! 601:
! 602: if ((error = copyin(SCARG(uap, sigcntxp), &sc, sizeof sc)) != 0)
! 603: return error;
! 604: tf = trapframe(p);
! 605: if ((sc.sc_frame.srr1 & PSL_USERSTATIC) != (tf->srr1 & PSL_USERSTATIC))
! 606: return EINVAL;
! 607: bcopy(&sc.sc_frame, tf, sizeof *tf);
! 608: if (sc.sc_onstack & 1)
! 609: p->p_sigacts->ps_sigstk.ss_flags |= SS_ONSTACK;
! 610: else
! 611: p->p_sigacts->ps_sigstk.ss_flags &= ~SS_ONSTACK;
! 612: p->p_sigmask = sc.sc_mask & ~sigcantmask;
! 613: return EJUSTRETURN;
! 614: }
! 615:
! 616: /*
! 617: * Machine dependent system variables.
! 618: * None for now.
! 619: */
! 620: int
! 621: cpu_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
! 622: int *name;
! 623: u_int namelen;
! 624: void *oldp;
! 625: size_t *oldlenp;
! 626: void *newp;
! 627: size_t newlen;
! 628: struct proc *p;
! 629: {
! 630: /* all sysctl names at this level are terminal */
! 631: if (namelen != 1)
! 632: return ENOTDIR;
! 633: switch (name[0]) {
! 634: default:
! 635: return EOPNOTSUPP;
! 636: }
! 637: }
! 638:
! 639: void
! 640: dumpsys()
! 641: {
! 642: printf("dumpsys: TBD\n");
! 643: }
! 644:
! 645: volatile int cpl, ipending, astpending;
! 646: int imask[IPL_NUM];
! 647: int netisr;
! 648:
! 649: /*
! 650: * Soft networking interrupts.
! 651: */
! 652: void
! 653: softnet(isr)
! 654: int isr;
! 655: {
! 656: #define DONETISR(flag, func) \
! 657: if (isr & (1 << (flag))) \
! 658: (func)();
! 659:
! 660: #include <net/netisr_dispatch.h>
! 661: #undef DONETISR
! 662: }
! 663:
! 664: int
! 665: lcsplx(ipl)
! 666: int ipl;
! 667: {
! 668: int oldcpl;
! 669:
! 670: oldcpl = cpl;
! 671: splx(ipl);
! 672: return oldcpl;
! 673: }
! 674:
! 675: /*
! 676: * Halt or reboot the machine after syncing/dumping according to howto.
! 677: */
! 678: void
! 679: boot(howto)
! 680: int howto;
! 681: {
! 682: static int syncing;
! 683: static char str[256];
! 684:
! 685: boothowto = howto;
! 686: if (!cold && !(howto & RB_NOSYNC) && !syncing) {
! 687: syncing = 1;
! 688: vfs_shutdown(); /* sync */
! 689:
! 690: /*
! 691: * If we've been adjusting the clock, the todr
! 692: * will be out of synch; adjust it now unless
! 693: * the system was sitting in ddb.
! 694: */
! 695: if ((howto & RB_TIMEBAD) == 0) {
! 696: resettodr();
! 697: } else {
! 698: printf("WARNING: not updating battery clock\n");
! 699: }
! 700: }
! 701: splhigh();
! 702: if (howto & RB_HALT) {
! 703: doshutdownhooks();
! 704: printf("halted\n\n");
! 705: (fw->exit)();
! 706: }
! 707: if (!cold && (howto & RB_DUMP))
! 708: dumpsys();
! 709: doshutdownhooks();
! 710: printf("rebooting\n\n");
! 711:
! 712: (fw->boot)(str);
! 713: for (;;) ; /* spinning */
! 714: }
! 715:
! 716: /*
! 717: * Get Ethernet address for the onboard ethernet chip.
! 718: */
! 719: void
! 720: myetheraddr(cp)
! 721: u_char *cp;
! 722: {
! 723: struct mvmeprom_brdid brdid;
! 724:
! 725: mvmeprom_brdid(&brdid);
! 726: bcopy(&brdid.etheraddr, cp, 6);
! 727: }
! 728:
! 729: typedef void (void_f) (void);
! 730: void_f *pending_int_f = NULL;
! 731:
! 732: /* call the bus/interrupt controller specific pending interrupt handler
! 733: * would be nice if the offlevel interrupt code was handled here
! 734: * instead of being in each of the specific handler code
! 735: */
! 736: void
! 737: do_pending_int()
! 738: {
! 739: if (pending_int_f != NULL) {
! 740: (*pending_int_f)();
! 741: }
! 742: }
! 743:
! 744: /*
! 745: * one attempt at interrupt stuff..
! 746: *
! 747: */
! 748: #include <dev/pci/pcivar.h>
! 749: typedef void *(intr_establish_t)(void *, pci_intr_handle_t,
! 750: int, int, int (*func)(void *), void *, char *);
! 751: typedef void (intr_disestablish_t)(void *, void *);
! 752:
! 753: int ppc_configed_intr_cnt = 0;
! 754: struct intrhand ppc_configed_intr[MAX_PRECONF_INTR];
! 755:
! 756: void *ppc_intr_establish(void *, pci_intr_handle_t, int, int, int (*)(void *),
! 757: void *, char *);
! 758: void ppc_intr_setup(intr_establish_t *, intr_disestablish_t *);
! 759: void ppc_intr_enable(int);
! 760: int ppc_intr_disable(void);
! 761:
! 762: void *
! 763: ppc_intr_establish(lcv, ih, type, level, func, arg, name)
! 764: void *lcv;
! 765: pci_intr_handle_t ih;
! 766: int type;
! 767: int level;
! 768: int (*func)(void *);
! 769: void *arg;
! 770: char *name;
! 771: {
! 772: if (ppc_configed_intr_cnt < MAX_PRECONF_INTR) {
! 773: ppc_configed_intr[ppc_configed_intr_cnt].ih_fun = func;
! 774: ppc_configed_intr[ppc_configed_intr_cnt].ih_arg = arg;
! 775: ppc_configed_intr[ppc_configed_intr_cnt].ih_level = level;
! 776: ppc_configed_intr[ppc_configed_intr_cnt].ih_irq = ih;
! 777: ppc_configed_intr[ppc_configed_intr_cnt].ih_what = name;
! 778: ppc_configed_intr_cnt++;
! 779: } else {
! 780: panic("ppc_intr_establish called before interrupt controller"
! 781: " configured: driver %s has too many interrupts", name);
! 782: }
! 783: /* disestablish is going to be tricky to supported for these :-) */
! 784: return (void *)ppc_configed_intr_cnt;
! 785: }
! 786:
! 787: intr_establish_t *intr_establish_func = ppc_intr_establish;
! 788: intr_disestablish_t *intr_disestablish_func;
! 789:
! 790: void
! 791: ppc_intr_setup(intr_establish_t *establish, intr_disestablish_t *disestablish)
! 792: {
! 793: intr_establish_func = establish;
! 794: intr_disestablish_func = disestablish;
! 795: }
! 796:
! 797: vaddr_t ppc_kvm_stolen = VM_KERN_ADDRESS_SIZE;
! 798:
! 799: void *
! 800: mapiodev(pa, len)
! 801: paddr_t pa;
! 802: psize_t len;
! 803: {
! 804: paddr_t spa;
! 805: vaddr_t vaddr, va;
! 806: int off;
! 807: int size;
! 808:
! 809: spa = trunc_page(pa);
! 810: off = pa - spa;
! 811: size = round_page(off+len);
! 812:
! 813: if (ppc_malloc_ok == 0) {
! 814: /* need to steal vm space before kernel vm is initialized */
! 815: va = VM_MIN_KERNEL_ADDRESS + ppc_kvm_stolen;
! 816: ppc_kvm_stolen += size;
! 817: if (ppc_kvm_stolen > PPC_SEGMENT_LENGTH) {
! 818: panic("ppc_kvm_stolen: out of space");
! 819: }
! 820: } else {
! 821: va = uvm_km_valloc_wait(phys_map, size);
! 822: }
! 823:
! 824: if (va == 0)
! 825: return NULL;
! 826:
! 827: for (vaddr = va; size > 0; size -= PAGE_SIZE) {
! 828: pmap_kenter_cache(vaddr, spa,
! 829: VM_PROT_READ | VM_PROT_WRITE, PMAP_CACHE_DEFAULT);
! 830: spa += PAGE_SIZE;
! 831: vaddr += PAGE_SIZE;
! 832: }
! 833: return (void *) (va+off);
! 834: }
! 835: void
! 836: unmapiodev(kva, p_size)
! 837: void *kva;
! 838: psize_t p_size;
! 839: {
! 840: vaddr_t vaddr;
! 841: int size;
! 842:
! 843: size = p_size;
! 844:
! 845: vaddr = trunc_page((vaddr_t)kva);
! 846:
! 847: uvm_km_free_wakeup(phys_map, vaddr, size);
! 848:
! 849: for (; size > 0; size -= PAGE_SIZE) {
! 850: pmap_remove(pmap_kernel(), vaddr, vaddr+PAGE_SIZE-1);
! 851: vaddr += PAGE_SIZE;
! 852: }
! 853: pmap_update(pmap_kernel());
! 854: }
! 855:
! 856: /* bcopy(), error on fault */
! 857: int
! 858: kcopy(from, to, size)
! 859: const void *from;
! 860: void *to;
! 861: size_t size;
! 862: {
! 863: faultbuf env;
! 864: void *oldh = curproc->p_addr->u_pcb.pcb_onfault;
! 865:
! 866: if (setfault(&env)) {
! 867: curproc->p_addr->u_pcb.pcb_onfault = oldh;
! 868: return EFAULT;
! 869: }
! 870: bcopy(from, to, size);
! 871: curproc->p_addr->u_pcb.pcb_onfault = oldh;
! 872:
! 873: return 0;
! 874: }
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 / mvmeppc / mvmeppc