sys/arch/sun3/sun3x/machdep.c

   1 /*      $NetBSD: machdep.c,v 1.121 2009/11/21 04:16:53 rmind Exp $      */
   2
   3 /*
   4  * Copyright (c) 1982, 1986, 1990, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * the Systems Programming Group of the University of Utah Computer
   9  * Science Department.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  *
  35  *      from: Utah Hdr: machdep.c 1.74 92/12/20
  36  *      from: @(#)machdep.c     8.10 (Berkeley) 4/20/94
  37  */
  38 /*
  39  * Copyright (c) 1988 University of Utah.
  40  *
  41  * This code is derived from software contributed to Berkeley by
  42  * the Systems Programming Group of the University of Utah Computer
  43  * Science Department.
  44  *
  45  * Redistribution and use in source and binary forms, with or without
  46  * modification, are permitted provided that the following conditions
  47  * are met:
  48  * 1. Redistributions of source code must retain the above copyright
  49  *    notice, this list of conditions and the following disclaimer.
  50  * 2. Redistributions in binary form must reproduce the above copyright
  51  *    notice, this list of conditions and the following disclaimer in the
  52  *    documentation and/or other materials provided with the distribution.
  53  * 3. All advertising materials mentioning features or use of this software
  54  *    must display the following acknowledgement:
  55  *      This product includes software developed by the University of
  56  *      California, Berkeley and its contributors.
  57  * 4. Neither the name of the University nor the names of its contributors
  58  *    may be used to endorse or promote products derived from this software
  59  *    without specific prior written permission.
  60  *
  61  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  62  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  63  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  64  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  65  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  66  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  67  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  68  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  69  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  70  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  71  * SUCH DAMAGE.
  72  *
  73  *      from: Utah Hdr: machdep.c 1.74 92/12/20
  74  *      from: @(#)machdep.c     8.10 (Berkeley) 4/20/94
  75  */
  76
  77 #include <sys/cdefs.h>
  78 __KERNEL_RCSID(0, "$NetBSD: machdep.c,v 1.121 2009/11/21 04:16:53 rmind Exp $");
  79
  80 #include "opt_ddb.h"
  81 #include "opt_kgdb.h"
  82 #include "opt_modular.h"
  83
  84 #include <sys/param.h>
  85 #include <sys/systm.h>
  86 #include <sys/kernel.h>
  87 #include <sys/proc.h>
  88 #include <sys/buf.h>
  89 #include <sys/reboot.h>
  90 #include <sys/conf.h>
  91 #include <sys/file.h>
  92 #include <sys/device.h>
  93 #include <sys/malloc.h>
  94 #include <sys/mbuf.h>
  95 #include <sys/msgbuf.h>
  96 #include <sys/ioctl.h>
  97 #include <sys/tty.h>
  98 #include <sys/mount.h>
  99 #include <sys/exec.h>
 100 #include <sys/exec_aout.h>              /* for MID_* */
 101 #include <sys/core.h>
 102 #include <sys/kcore.h>
 103 #include <sys/vnode.h>
 104 #include <sys/syscallargs.h>
 105 #include <sys/ksyms.h>
 106 #ifdef  KGDB
 107 #include <sys/kgdb.h>
 108 #endif
 109
 110 #include <uvm/uvm_extern.h>
 111
 112 #include <sys/sysctl.h>
 113
 114 #include <dev/cons.h>
 115
 116 #include <machine/cpu.h>
 117 #include <machine/dvma.h>
 118 #include <machine/idprom.h>
 119 #include <machine/kcore.h>
 120 #include <machine/reg.h>
 121 #include <machine/psl.h>
 122 #include <machine/pte.h>
 123
 124 #if defined(DDB)
 125 #include <machine/db_machdep.h>
 126 #include <ddb/db_sym.h>
 127 #include <ddb/db_extern.h>
 128 #endif
 129
 130 #include <sun3/sun3/machdep.h>
 131
 132 #include "ksyms.h"
 133
 134 /* Defined in locore.s */
 135 extern char kernel_text[];
 136 /* Defined by the linker */
 137 extern char etext[];
 138
 139 /* Our exported CPU info; we can have only one. */
 140 struct cpu_info cpu_info_store;
 141
 142 struct vm_map *mb_map = NULL;
 143 struct vm_map *phys_map = NULL;
 144
 145 int     physmem;
 146 int     fputype;
 147 void *  msgbufaddr;
 148
 149 /* Virtual page frame for /dev/mem (see mem.c) */
 150 vaddr_t vmmap;
 151
 152 /*
 153  * safepri is a safe priority for sleep to set for a spin-wait
 154  * during autoconfiguration or after a panic.
 155  */
 156 int     safepri = PSL_LOWIPL;
 157
 158 u_char cpu_machine_id = 0;
 159 const char *cpu_string = NULL;
 160 int cpu_has_vme = 0;
 161 int has_iocache = 0;
 162
 163 vaddr_t dumppage;
 164
 165 static void identifycpu(void);
 166 static void initcpu(void);
 167
 168 /*
 169  * Console initialization: called early on from main,
 170  * before vm init or cpu_startup.  This system is able
 171  * to use the console for output immediately (via PROM)
 172  * but can not use it for input until after this point.
 173  */
 174 void
 175 consinit(void)
 176 {
 177
 178         /*
 179          * Switch from the PROM console (output only)
 180          * to our own console driver.
 181          */
 182         cninit();
 183
 184 #if NKSYMS || defined(DDB) || defined(MODULAR)
 185         {
 186                 extern int nsym;
 187                 extern char *ssym, *esym;
 188
 189                 ksyms_addsyms_elf(nsym, ssym, esym);
 190         }
 191 #endif  /* DDB */
 192
 193         /*
 194          * Now that the console can do input as well as
 195          * output, consider stopping for a debugger.
 196          */
 197         if (boothowto & RB_KDB) {
 198 #ifdef KGDB
 199                 /* XXX - Ask on console for kgdb_dev? */
 200                 /* Note: this will just return if kgdb_dev==NODEV */
 201                 kgdb_connect(1);
 202 #else   /* KGDB */
 203                 /* Either DDB or no debugger (just PROM). */
 204                 Debugger();
 205 #endif  /* KGDB */
 206         }
 207 }
 208
 209 /*
 210  * cpu_startup: allocate memory for variable-sized tables,
 211  * initialize CPU, and do autoconfiguration.
 212  *
 213  * This is called early in init_main.c:main(), after the
 214  * kernel memory allocator is ready for use, but before
 215  * the creation of processes 1,2, and mountroot, etc.
 216  */
 217 void
 218 cpu_startup(void)
 219 {
 220         char *v;
 221         vaddr_t minaddr, maxaddr;
 222         char pbuf[9];
 223
 224         /*
 225          * Initialize message buffer (for kernel printf).
 226          * This is put in physical page zero so it will
 227          * always be in the same place after a reboot.
 228          * Its mapping was prepared in pmap_bootstrap().
 229          * Also, offset some to avoid PROM scribbles.
 230          */
 231         v = (char *)KERNBASE;
 232         msgbufaddr = v + MSGBUFOFF;
 233         initmsgbuf(msgbufaddr, MSGBUFSIZE);
 234
 235         /*
 236          * Good {morning,afternoon,evening,night}.
 237          */
 238         printf("%s%s", copyright, version);
 239         identifycpu();
 240         initfpu();      /* also prints FPU type */
 241
 242         format_bytes(pbuf, sizeof(pbuf), ctob(physmem));
 243         printf("total memory = %s\n", pbuf);
 244
 245         /*
 246          * Get scratch page for dumpsys().
 247          */
 248         dumppage = uvm_km_alloc(kernel_map, PAGE_SIZE, 0, UVM_KMF_WIRED);
 249         if (dumppage == 0)
 250                 panic("startup: alloc dumppage");
 251
 252         minaddr = 0;
 253
 254         /*
 255          * Allocate a submap for physio
 256          */
 257         phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
 258                                    VM_PHYS_SIZE, 0, false, NULL);
 259
 260         /*
 261          * Finally, allocate mbuf cluster submap.
 262          */
 263         mb_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
 264                                  nmbclusters * mclbytes, VM_MAP_INTRSAFE,
 265                                  false, NULL);
 266
 267         format_bytes(pbuf, sizeof(pbuf), ptoa(uvmexp.free));
 268         printf("avail memory = %s\n", pbuf);
 269
 270         /*
 271          * Allocate a virtual page (for use by /dev/mem)
 272          * This page is handed to pmap_enter() therefore
 273          * it has to be in the normal kernel VA range.
 274          */
 275         vmmap = uvm_km_alloc(kernel_map, PAGE_SIZE, 0,
 276             UVM_KMF_VAONLY | UVM_KMF_WAITVA);
 277
 278         /*
 279          * Create the DVMA maps.
 280          */
 281         dvma_init();
 282
 283         /*
 284          * Set up CPU-specific registers, cache, etc.
 285          */
 286         initcpu();
 287 }
 288
 289 /*
 290  * Set registers on exec.
 291  */
 292 void
 293 setregs(struct lwp *l, struct exec_package *pack, vaddr_t stack)
 294 {
 295         struct trapframe *tf = (struct trapframe *)l->l_md.md_regs;
 296         struct pcb *pcb = lwp_getpcb(l);
 297
 298         tf->tf_sr = PSL_USERSET;
 299         tf->tf_pc = pack->ep_entry & ~1;
 300         tf->tf_regs[D0] = 0;
 301         tf->tf_regs[D1] = 0;
 302         tf->tf_regs[D2] = 0;
 303         tf->tf_regs[D3] = 0;
 304         tf->tf_regs[D4] = 0;
 305         tf->tf_regs[D5] = 0;
 306         tf->tf_regs[D6] = 0;
 307         tf->tf_regs[D7] = 0;
 308         tf->tf_regs[A0] = 0;
 309         tf->tf_regs[A1] = 0;
 310         tf->tf_regs[A2] = (int)l->l_proc->p_psstr;
 311         tf->tf_regs[A3] = 0;
 312         tf->tf_regs[A4] = 0;
 313         tf->tf_regs[A5] = 0;
 314         tf->tf_regs[A6] = 0;
 315         tf->tf_regs[SP] = stack;
 316
 317         /* restore a null state frame */
 318         pcb->pcb_fpregs.fpf_null = 0;
 319         if (fputype)
 320                 m68881_restore(&pcb->pcb_fpregs);
 321
 322         l->l_md.md_flags = 0;
 323 }
 324
 325 /*
 326  * Info for CTL_HW
 327  */
 328 char    machine[16] = MACHINE;          /* from <machine/param.h> */
 329 char    kernel_arch[16] = "sun3x";      /* XXX needs a sysctl node */
 330 char    cpu_model[120];
 331
 332 /*
 333  * XXX - Should empirically estimate the divisor...
 334  * Note that the value of delay_divisor is roughly
 335  * 2048 / cpuclock      (where cpuclock is in MHz).
 336  */
 337 int delay_divisor = 62;         /* assume the fastest (33 MHz) */
 338
 339 void
 340 identifycpu(void)
 341 {
 342         u_char machtype;
 343
 344         machtype = identity_prom.idp_machtype;
 345         if ((machtype & IDM_ARCH_MASK) != IDM_ARCH_SUN3X) {
 346                 printf("Bad IDPROM arch!\n");
 347                 sunmon_abort();
 348         }
 349
 350         cpu_machine_id = machtype;
 351         switch (cpu_machine_id) {
 352
 353         case ID_SUN3X_80:
 354                 cpu_string = "80";      /* Hydra */
 355                 delay_divisor = 102;    /* 20 MHz */
 356                 cpu_has_vme = false;
 357                 break;
 358
 359         case ID_SUN3X_470:
 360                 cpu_string = "470";     /* Pegasus */
 361                 delay_divisor = 62;     /* 33 MHz */
 362                 cpu_has_vme = true;
 363                 break;
 364
 365         default:
 366                 printf("unknown sun3x model\n");
 367                 sunmon_abort();
 368         }
 369
 370         /* Other stuff? (VAC, mc6888x version, etc.) */
 371         /* Note: miniroot cares about the kernel_arch part. */
 372         sprintf(cpu_model, "%s %s", kernel_arch, cpu_string);
 373
 374         printf("Model: %s\n", cpu_model);
 375 }
 376
 377 /*
 378  * machine dependent system variables.
 379  */
 380 #if 0   /* XXX - Not yet... */
 381 static int
 382 sysctl_machdep_root_device(SYSCTLFN_ARGS)
 383 {
 384         struct sysctlnode node = *rnode;
 385
 386         node.sysctl_data = some permutation on root_device;
 387         node.sysctl_size = strlen(root_device) + 1;
 388         return (sysctl_lookup(SYSCTLFN_CALL(&node)));
 389 }
 390
 391 static int
 392 sysctl_machdep_booted_kernel(SYSCTLFN_ARGS)
 393 {
 394         struct sysctlnode node = *rnode;
 395
 396         node.sysctl_data = some permutation on booted_kernel;
 397         node.sysctl_size = strlen(booted_kernel) + 1;
 398         return (sysctl_lookup(SYSCTLFN_CALL(&node)));
 399 }
 400 #endif
 401
 402 SYSCTL_SETUP(sysctl_machdep_setup, "sysctl machdep subtree setup")
 403 {
 404
 405         sysctl_createv(clog, 0, NULL, NULL,
 406                        CTLFLAG_PERMANENT,
 407                        CTLTYPE_NODE, "machdep", NULL,
 408                        NULL, 0, NULL, 0,
 409                        CTL_MACHDEP, CTL_EOL);
 410
 411         sysctl_createv(clog, 0, NULL, NULL,
 412                        CTLFLAG_PERMANENT,
 413                        CTLTYPE_STRUCT, "console_device", NULL,
 414                        sysctl_consdev, 0, NULL, sizeof(dev_t),
 415                        CTL_MACHDEP, CPU_CONSDEV, CTL_EOL);
 416 #if 0 /* XXX - Not yet... */
 417         sysctl_createv(clog, 0, NULL, NULL,
 418                        CTLFLAG_PERMANENT,
 419                        CTLTYPE_STRING, "root_device", NULL,
 420                        sysctl_machdep_root_device, 0, NULL, 0,
 421                        CTL_MACHDEP, CPU_ROOT_DEVICE, CTL_EOL);
 422         sysctl_createv(clog, 0, NULL, NULL,
 423                        CTLFLAG_PERMANENT,
 424                        CTLTYPE_STRING, "booted_kernel", NULL,
 425                        sysctl_machdep_booted_kernel, 0, NULL, 0,
 426                        CTL_MACHDEP, CPU_BOOTED_KERNEL, CTL_EOL);
 427 #endif
 428 }
 429
 430 /* See: sig_machdep.c */
 431
 432 /*
 433  * Do a sync in preparation for a reboot.
 434  * XXX - This could probably be common code.
 435  * XXX - And now, most of it is in vfs_shutdown()
 436  * XXX - Put waittime checks in there too?
 437  */
 438 int waittime = -1;      /* XXX - Who else looks at this? -gwr */
 439 static void
 440 reboot_sync(void)
 441 {
 442
 443         /* Check waittime here to localize its use to this function. */
 444         if (waittime >= 0)
 445                 return;
 446         waittime = 0;
 447         vfs_shutdown();
 448 }
 449
 450 /*
 451  * Common part of the BSD and SunOS reboot system calls.
 452  */
 453 __dead void
 454 cpu_reboot(int howto, char *user_boot_string)
 455 {
 456         /* Note: this string MUST be static! */
 457         static char bootstr[128];
 458         char *p;
 459
 460         /* If system is cold, just halt. (early panic?) */
 461         if (cold)
 462                 goto haltsys;
 463
 464         /* Un-blank the screen if appropriate. */
 465         cnpollc(1);
 466
 467         if ((howto & RB_NOSYNC) == 0) {
 468                 reboot_sync();
 469                 /*
 470                  * If we've been adjusting the clock, the todr
 471                  * will be out of synch; adjust it now.
 472                  *
 473                  * XXX - However, if the kernel has been sitting in ddb,
 474                  * the time will be way off, so don't set the HW clock!
 475                  * XXX - Should do sanity check against HW clock. -gwr
 476                  */
 477                 /* resettodr(); */
 478         }
 479
 480         /* Disable interrupts. */
 481         splhigh();
 482
 483         /* Write out a crash dump if asked. */
 484         if (howto & RB_DUMP)
 485                 dumpsys();
 486
 487         /* run any shutdown hooks */
 488         doshutdownhooks();
 489
 490         pmf_system_shutdown(boothowto);
 491
 492         if (howto & RB_HALT) {
 493         haltsys:
 494                 printf("halted.\n");
 495                 sunmon_halt();
 496         }
 497
 498         /*
 499          * Automatic reboot.
 500          */
 501         if (user_boot_string)
 502                 strncpy(bootstr, user_boot_string, sizeof(bootstr));
 503         else {
 504                 /*
 505                  * Build our own boot string with an empty
 506                  * boot device/file and (maybe) some flags.
 507                  * The PROM will supply the device/file name.
 508                  */
 509                 p = bootstr;
 510                 *p = '\0';
 511                 if (howto & (RB_KDB|RB_ASKNAME|RB_SINGLE)) {
 512                         /* Append the boot flags. */
 513                         *p++ = ' ';
 514                         *p++ = '-';
 515                         if (howto & RB_KDB)
 516                                 *p++ = 'd';
 517                         if (howto & RB_ASKNAME)
 518                                 *p++ = 'a';
 519                         if (howto & RB_SINGLE)
 520                                 *p++ = 's';
 521                         *p = '\0';
 522                 }
 523         }
 524         printf("rebooting...\n");
 525         sunmon_reboot(bootstr);
 526         for (;;) ;
 527         /*NOTREACHED*/
 528 }
 529
 530 /*
 531  * These variables are needed by /sbin/savecore
 532  */
 533 uint32_t dumpmag = 0x8fca0101;  /* magic number */
 534 int     dumpsize = 0;           /* pages */
 535 long    dumplo = 0;             /* blocks */
 536
 537 #define DUMP_EXTRA      1       /* CPU-dependent extra pages */
 538
 539 /*
 540  * This is called by main to set dumplo, dumpsize.
 541  * Dumps always skip the first PAGE_SIZE of disk space
 542  * in case there might be a disk label stored there.
 543  * If there is extra space, put dump at the end to
 544  * reduce the chance that swapping trashes it.
 545  */
 546 void
 547 cpu_dumpconf(void)
 548 {
 549         const struct bdevsw *bdev;
 550         int devblks;    /* size of dump device in blocks */
 551         int dumpblks;   /* size of dump image in blocks */
 552         int (*getsize)(dev_t);
 553
 554         if (dumpdev == NODEV)
 555                 return;
 556
 557         bdev = bdevsw_lookup(dumpdev);
 558         if (bdev == NULL) {
 559                 dumpdev = NODEV;
 560                 return;
 561         }
 562         getsize = bdev->d_psize;
 563         if (getsize == NULL)
 564                 return;
 565         devblks = (*getsize)(dumpdev);
 566         if (devblks <= ctod(1))
 567                 return;
 568         devblks &= ~(ctod(1) - 1);
 569
 570         /*
 571          * Note: savecore expects dumpsize to be the
 572          * number of pages AFTER the dump header.
 573          */
 574         dumpsize = physmem;     /* pages */
 575
 576         /* Position dump image near end of space, page aligned. */
 577         dumpblks = ctod(physmem + DUMP_EXTRA);
 578         dumplo = devblks - dumpblks;
 579
 580         /* If it does not fit, truncate it by moving dumplo. */
 581         /* Note: Must force signed comparison. */
 582         if (dumplo < ((long)ctod(1))) {
 583                 dumplo = ctod(1);
 584                 dumpsize = dtoc(devblks - dumplo) - DUMP_EXTRA;
 585         }
 586 }
 587
 588 /* Note: gdb looks for "dumppcb" in a kernel crash dump. */
 589 struct pcb dumppcb;
 590
 591 /*
 592  * Write a crash dump.  The format while in swap is:
 593  *   kcore_seg_t cpu_hdr;
 594  *   cpu_kcore_hdr_t cpu_data;
 595  *   padding (PAGE_SIZE-sizeof(kcore_seg_t))
 596  *   pagemap (2*PAGE_SIZE)
 597  *   physical memory...
 598  */
 599 void
 600 dumpsys(void)
 601 {
 602         const struct bdevsw *dsw;
 603         kcore_seg_t *kseg_p;
 604         cpu_kcore_hdr_t *chdr_p;
 605         struct sun3x_kcore_hdr *sh;
 606         phys_ram_seg_t *crs_p;
 607         char *vaddr;
 608         paddr_t paddr;
 609         int psize, todo, seg, segsz;
 610         daddr_t blkno;
 611         int error = 0;
 612
 613         if (dumpdev == NODEV)
 614                 return;
 615         dsw = bdevsw_lookup(dumpdev);
 616         if (dsw == NULL || dsw->d_psize == NULL)
 617                 return;
 618
 619         /*
 620          * For dumps during autoconfiguration,
 621          * if dump device has already configured...
 622          */
 623         if (dumpsize == 0)
 624                 cpu_dumpconf();
 625         if (dumplo <= 0) {
 626                 printf("\ndump to dev %u,%u not possible\n",
 627                     major(dumpdev), minor(dumpdev));
 628                 return;
 629         }
 630         savectx(&dumppcb);
 631
 632         psize = (*(dsw->d_psize))(dumpdev);
 633         if (psize == -1) {
 634                 printf("dump area unavailable\n");
 635                 return;
 636         }
 637
 638         printf("\ndumping to dev %u,%u offset %ld\n",
 639             major(dumpdev), minor(dumpdev), dumplo);
 640
 641         /*
 642          * Prepare the dump header
 643          */
 644         blkno = dumplo;
 645         todo = dumpsize;        /* pages */
 646         vaddr = (char *)dumppage;
 647         memset(vaddr, 0, PAGE_SIZE);
 648
 649         /* Set pointers to all three parts. */
 650         kseg_p = (kcore_seg_t *)vaddr;
 651         chdr_p = (cpu_kcore_hdr_t *)(kseg_p + 1);
 652         sh = &chdr_p->un._sun3x;
 653
 654         /* Fill in kcore_seg_t part. */
 655         CORE_SETMAGIC(*kseg_p, KCORE_MAGIC, MID_MACHINE, CORE_CPU);
 656         kseg_p->c_size = (ctob(DUMP_EXTRA) - sizeof(*kseg_p));
 657
 658         /* Fill in cpu_kcore_hdr_t part. */
 659         strncpy(chdr_p->name, kernel_arch, sizeof(chdr_p->name));
 660         chdr_p->page_size = PAGE_SIZE;
 661         chdr_p->kernbase = KERNBASE;
 662
 663         /* Fill in the sun3x_kcore_hdr part. */
 664         pmap_kcore_hdr(sh);
 665
 666         /* Write out the dump header. */
 667         error = (*dsw->d_dump)(dumpdev, blkno, vaddr, PAGE_SIZE);
 668         if (error)
 669                 goto fail;
 670         blkno += btodb(PAGE_SIZE);
 671
 672         /*
 673          * Now dump physical memory.  Note that physical memory
 674          * might NOT be congiguous, so do it by segments.
 675          */
 676
 677         vaddr = (char *)vmmap;  /* Borrow /dev/mem VA */
 678
 679         for (seg = 0; seg < SUN3X_NPHYS_RAM_SEGS; seg++) {
 680                 crs_p = &sh->ram_segs[seg];
 681                 paddr = crs_p->start;
 682                 segsz = crs_p->size;
 683
 684                 while (todo && (segsz > 0)) {
 685
 686                         /* Print pages left after every 16. */
 687                         if ((todo & 0xf) == 0)
 688                                 printf_nolog("\r%4d", todo);
 689
 690                         /* Make a temporary mapping for the page. */
 691                         pmap_kenter_pa(vmmap, paddr | PMAP_NC, VM_PROT_READ, 0);
 692                         pmap_update(pmap_kernel());
 693                         error = (*dsw->d_dump)(dumpdev, blkno, vaddr,
 694                                                PAGE_SIZE);
 695                         pmap_kremove(vmmap, PAGE_SIZE);
 696                         pmap_update(pmap_kernel());
 697                         if (error)
 698                                 goto fail;
 699                         paddr += PAGE_SIZE;
 700                         segsz -= PAGE_SIZE;
 701                         blkno += btodb(PAGE_SIZE);
 702                         todo--;
 703                 }
 704         }
 705         printf("\rdump succeeded\n");
 706         return;
 707 fail:
 708         printf(" dump error=%d\n", error);
 709 }
 710
 711 static void
 712 initcpu(void)
 713 {
 714         /* XXX: Enable RAM parity/ECC checking? */
 715         /* XXX: parityenable(); */
 716
 717 #ifdef  HAVECACHE
 718         cache_enable();
 719 #endif
 720 }
 721
 722 /* straptrap() in trap.c */
 723
 724 /* from hp300: badaddr() */
 725 /* peek_byte(), peek_word() moved to bus_subr.c */
 726
 727 /* XXX: parityenable() ? */
 728 /* regdump() moved to regdump.c */
 729
 730 /*
 731  * cpu_exec_aout_makecmds():
 732  *      CPU-dependent a.out format hook for execve().
 733  *
 734  * Determine if the given exec package refers to something which we
 735  * understand and, if so, set up the vmcmds for it.
 736  */
 737 int
 738 cpu_exec_aout_makecmds(struct lwp *l, struct exec_package *epp)
 739 {
 740         return ENOEXEC;
 741 }