![[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 / mac68k / mac68k|
Return to machdep.c CVS log | Up to [local] / sys / arch / mac68k / mac68k |
1.1 nbrk 1: /* $OpenBSD: machdep.c,v 1.142 2007/07/29 21:24:05 miod Exp $ */
2: /* $NetBSD: machdep.c,v 1.207 1998/07/08 04:39:34 thorpej Exp $ */
3:
4: /*
5: * Copyright (c) 1988 University of Utah.
6: * Copyright (c) 1982, 1990 The Regents of the University of California.
7: * All rights reserved.
8: *
9: * This code is derived from software contributed to Berkeley by
10: * the Systems Programming Group of the University of Utah Computer
11: * Science Department.
12: *
13: * Redistribution and use in source and binary forms, with or without
14: * modification, are permitted provided that the following conditions
15: * are met:
16: * 1. Redistributions of source code must retain the above copyright
17: * notice, this list of conditions and the following disclaimer.
18: * 2. Redistributions in binary form must reproduce the above copyright
19: * notice, this list of conditions and the following disclaimer in the
20: * documentation and/or other materials provided with the distribution.
21: * 3. Neither the name of the University nor the names of its contributors
22: * may be used to endorse or promote products derived from this software
23: * without specific prior written permission.
24: *
25: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35: * SUCH DAMAGE.
36: */
37: /*-
38: * Copyright (C) 1993 Allen K. Briggs, Chris P. Caputo,
39: * Michael L. Finch, Bradley A. Grantham, and
40: * Lawrence A. Kesteloot
41: * All rights reserved.
42: *
43: * Redistribution and use in source and binary forms, with or without
44: * modification, are permitted provided that the following conditions
45: * are met:
46: * 1. Redistributions of source code must retain the above copyright
47: * notice, this list of conditions and the following disclaimer.
48: * 2. Redistributions in binary form must reproduce the above copyright
49: * notice, this list of conditions and the following disclaimer in the
50: * documentation and/or other materials provided with the distribution.
51: * 3. All advertising materials mentioning features or use of this software
52: * must display the following acknowledgement:
53: * This product includes software developed by the Alice Group.
54: * 4. The names of the Alice Group or any of its members may not be used
55: * to endorse or promote products derived from this software without
56: * specific prior written permission.
57: *
58: * THIS SOFTWARE IS PROVIDED BY THE ALICE GROUP ``AS IS'' AND ANY EXPRESS OR
59: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
60: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
61: * IN NO EVENT SHALL THE ALICE GROUP BE LIABLE FOR ANY DIRECT, INDIRECT,
62: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
63: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
64: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
65: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
66: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
67: * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
68: *
69: */
70: /*
71: * from: Utah $Hdr: machdep.c 1.63 91/04/24$
72: *
73: * @(#)machdep.c 7.16 (Berkeley) 6/3/91
74: */
75:
76: #include <sys/param.h>
77: #include <sys/systm.h>
78: #include <sys/signalvar.h>
79: #include <sys/kernel.h>
80: #include <sys/proc.h>
81: #include <sys/buf.h>
82: #include <sys/exec.h>
83: #include <sys/core.h>
84: #include <sys/kcore.h>
85: #include <sys/vnode.h>
86: #include <sys/reboot.h>
87: #include <sys/conf.h>
88: #include <sys/file.h>
89: #include <sys/timeout.h>
90: #include <sys/malloc.h>
91: #include <sys/mbuf.h>
92: #include <sys/msgbuf.h>
93: #include <sys/user.h>
94: #include <sys/mount.h>
95: #include <sys/extent.h>
96: #include <sys/syscallargs.h>
97: #ifdef SYSVMSG
98: #include <sys/msg.h>
99: #endif
100:
101: #include <machine/db_machdep.h>
102: #include <ddb/db_sym.h>
103: #include <ddb/db_extern.h>
104: #include <ddb/db_var.h>
105:
106: #include <machine/autoconf.h>
107: #include <machine/cpu.h>
108: #include <machine/reg.h>
109: #include <machine/psl.h>
110: #include <machine/pte.h>
111: #include <machine/kcore.h>
112: #include <machine/bus.h>
113: #include <machine/pmap.h>
114:
115: #include <uvm/uvm_extern.h>
116:
117: #include <sys/sysctl.h>
118:
119: #include <dev/cons.h>
120: #include <mac68k/dev/adbvar.h>
121:
122: #include <machine/iop.h>
123: #include <machine/psc.h>
124: #include <machine/viareg.h>
125:
126: #include "wsdisplay.h"
127:
128: /* The following is used externally (sysctl_hw) */
129: char machine[] = MACHINE; /* from <machine/param.h> */
130:
131: struct mac68k_machine_S mac68k_machine;
132:
133: volatile u_char *Via1Base, *Via2Base, *PSCBase = NULL;
134: u_long NuBusBase = NBBASE;
135: u_long IOBase;
136:
137: vaddr_t SCSIBase;
138:
139: /* These are used to map kernel space: */
140: extern int numranges;
141: extern u_long low[8];
142: extern u_long high[8];
143:
144: /* These are used to map NuBus space: */
145: #define NBMAXRANGES 16
146: int nbnumranges; /* = 0 == don't use the ranges */
147: u_long nbphys[NBMAXRANGES]; /* Start physical addr of this range */
148: u_long nblog[NBMAXRANGES]; /* Start logical addr of this range */
149: long nblen[NBMAXRANGES]; /* Length of this range If the length is */
150: /* negative, all phys addrs are the same. */
151:
152: /* From Booter via locore */
153: long videoaddr; /* Addr used in kernel for video. */
154: long videorowbytes; /* Used in kernel for video. */
155: long videobitdepth; /* Number of bihs per pixel */
156: u_long videosize; /* height = 31:16, width 15:0 */
157:
158: /*
159: * Values for IIvx-like internal video
160: * -- should be zero if it is not used (usual case).
161: */
162: u_int32_t mac68k_vidlog; /* logical addr */
163: u_int32_t mac68k_vidphys; /* physical addr */
164: u_int32_t mac68k_vidlen; /* mem length */
165:
166: /* Callback and cookie to run bell */
167: int (*mac68k_bell_callback)(void *, int, int, int);
168: caddr_t mac68k_bell_cookie;
169:
170: struct vm_map *exec_map = NULL;
171: struct vm_map *phys_map = NULL;
172:
173: /*
174: * Declare these as initialized data so we can patch them.
175: */
176: #ifndef BUFCACHEPERCENT
177: #define BUFCACHEPERCENT 5
178: #endif
179:
180: #ifdef BUFPAGES
181: int bufpages = BUFPAGES;
182: #else
183: int bufpages = 0;
184: #endif
185: int bufcachepercent = BUFCACHEPERCENT;
186:
187: int physmem; /* size of physical memory, in pages */
188:
189: /*
190: * safepri is a safe priority for sleep to set for a spin-wait
191: * during autoconfiguration or after a panic.
192: */
193: int safepri = PSL_LOWIPL;
194:
195: /*
196: * Extent maps to manage all memory space, including I/O ranges. Allocate
197: * storage for 8 regions in each, initially. Later, iomem_malloc_safe
198: * will indicate that it's safe to use malloc() to dynamically allocate
199: * region descriptors.
200: *
201: * The extent maps are not static! Machine-dependent NuBus and on-board
202: * I/O routines need access to them for bus address space allocation.
203: */
204: long iomem_ex_storage[EXTENT_FIXED_STORAGE_SIZE(8) / sizeof(long)];
205: struct extent *iomem_ex;
206: int iomem_malloc_safe;
207:
208: /* XXX should be in locore.s for consistency */
209: int astpending = 0;
210:
211: void identifycpu(void);
212: u_long get_physical(u_int, u_long *);
213:
214: caddr_t allocsys(caddr_t);
215: void initcpu(void);
216: int cpu_dumpsize(void);
217: int cpu_dump(int (*)(dev_t, daddr64_t, caddr_t, size_t), daddr64_t *);
218: void cpu_init_kcore_hdr(void);
219: int fpu_probe(void);
220:
221: /* functions called from locore.s */
222: void dumpsys(void);
223: void mac68k_init(void);
224: void straytrap(int, int);
225: void nmihand(struct frame);
226:
227: /*
228: * Machine-dependent crash dump header info.
229: */
230: cpu_kcore_hdr_t cpu_kcore_hdr;
231:
232: /*
233: * Early initialization, before main() is called.
234: */
235: void
236: mac68k_init()
237: {
238: int i;
239: extern vaddr_t avail_start;
240:
241: /*
242: * Tell the VM system about available physical memory.
243: * Notice that we don't need to worry about avail_end here
244: * since it's equal to high[numranges-1].
245: */
246: for (i = 0; i < numranges; i++) {
247: if (low[i] <= avail_start && avail_start < high[i])
248: uvm_page_physload(atop(avail_start), atop(high[i]),
249: atop(avail_start), atop(high[i]),
250: VM_FREELIST_DEFAULT);
251: else
252: uvm_page_physload(atop(low[i]), atop(high[i]),
253: atop(low[i]), atop(high[i]),
254: VM_FREELIST_DEFAULT);
255: }
256:
257: /*
258: * Initialize the I/O mem extent map.
259: * Note: we don't have to check the return value since
260: * creation of a fixed extent map will never fail (since
261: * descriptor storage has already been allocated).
262: *
263: * N.B. The iomem extent manages _all_ physical addresses
264: * on the machine. When the amount of RAM is found, all
265: * extents of RAM are allocated from the map.
266: */
267: iomem_ex = extent_create("iomem", 0x0, 0xffffffff, M_DEVBUF,
268: (caddr_t)iomem_ex_storage, sizeof(iomem_ex_storage),
269: EX_NOCOALESCE|EX_NOWAIT);
270:
271: /* Initialize the interrupt handlers. */
272: intr_init();
273:
274: /* Initialize the VIAs */
275: via_init();
276:
277: /* Initialize the PSC (if present) */
278: psc_init();
279: }
280:
281: /*
282: * Console initialization: called early on from main,
283: * before vm init or startup. Do enough configuration
284: * to choose and initialize a console.
285: */
286: void
287: consinit(void)
288: {
289: /*
290: * Generic console: sys/dev/cons.c
291: * Initializes either ite or ser as console.
292: * Can be called from locore.s and init_main.c. (Ugh.)
293: */
294: static int init; /* = 0 */
295:
296: if (!init) {
297: cninit();
298: #ifdef DDB
299: /*
300: * Initialize kernel debugger, if compiled in.
301: */
302: ddb_init();
303: #endif
304: init = 1;
305: } else {
306: #if NWSDISPLAY > 0
307: /*
308: * XXX This is an evil hack on top of an evil hack!
309: *
310: * With the graybar stuff, we've got a catch-22: we need
311: * to do at least some console setup really early on, even
312: * before we're running with the mappings we need. On
313: * the other hand, we're not nearly ready to do anything
314: * with wscons or the ADB driver at that point.
315: *
316: * To get around this, wscninit() ignores the first call
317: * it gets (from cninit(), if not on a serial console).
318: * Once we're here, we call wscninit() again, which sets
319: * up the console devices and does the appropriate wscons
320: * initialization.
321: */
322: if (mac68k_machine.serial_console == 0) {
323: cons_decl(ws);
324: wscninit(NULL);
325: }
326: #endif
327:
328: mac68k_calibrate_delay();
329:
330: #if NZSC > 0 && defined(KGDB)
331: zs_kgdb_init();
332: #endif
333:
334: if (boothowto & RB_KDB) {
335: #ifdef KGDB
336: /* XXX - Ask on console for kgdb_dev? */
337: /* Note: this will just return if kgdb_dev==NODEV */
338: kgdb_connect(1);
339: #else /* KGDB */
340: #ifdef DDB
341: /* Enter DDB. We don't have a monitor PROM. */
342: Debugger();
343: #endif /* DDB */
344: #endif /* KGDB */
345: }
346: }
347: }
348:
349: #define CURRENTBOOTERVER 111
350:
351: /*
352: * cpu_startup: allocate memory for variable-sized tables,
353: * initialize cpu, and do autoconfiguration.
354: */
355: void
356: cpu_startup(void)
357: {
358: caddr_t v;
359: unsigned i;
360: int vers;
361: vaddr_t minaddr, maxaddr;
362: vsize_t size = 0; /* To avoid compiler warning */
363: int delay;
364:
365: /*
366: * Initialize the kernel crash dump header.
367: */
368: cpu_init_kcore_hdr();
369:
370: /*
371: * Initialize error message buffer (at end of core).
372: * high[numranges-1] was decremented in pmap_bootstrap.
373: */
374: for (i = 0; i < btoc(MSGBUFSIZE); i++)
375: pmap_enter(pmap_kernel(), (vaddr_t)msgbufp + i * NBPG,
376: high[numranges - 1] + i * NBPG,
377: VM_PROT_READ|VM_PROT_WRITE,
378: VM_PROT_READ|VM_PROT_WRITE|PMAP_WIRED);
379: pmap_update(pmap_kernel());
380: initmsgbuf((caddr_t)msgbufp, round_page(MSGBUFSIZE));
381:
382: /*
383: * Good {morning,afternoon,evening,night}.
384: */
385: printf(version);
386: identifycpu();
387:
388: vers = mac68k_machine.booter_version;
389: if (vers < CURRENTBOOTERVER) {
390: /* fix older booters with indices, not versions */
391: if (vers < 100)
392: vers += 99;
393:
394: printf("\nYou booted with booter version %d.%d.\n",
395: vers / 100, vers % 100);
396: printf("Booter version %d.%d is necessary to fully support\n",
397: CURRENTBOOTERVER / 100, CURRENTBOOTERVER % 100);
398: printf("this kernel.\n\n");
399: for (delay = 0; delay < 1000000; delay++);
400: }
401: printf("real mem = %u (%uMB)\n", ctob(physmem),
402: ctob(physmem)/1024/1024);
403:
404: /*
405: * Find out how much space we need, allocate it,
406: * and then give everything true virtual addressses.
407: */
408: size = (vsize_t)allocsys((caddr_t)0);
409: if ((v = (caddr_t)uvm_km_zalloc(kernel_map, round_page(size))) == 0)
410: panic("startup: no room for tables");
411: if ((allocsys(v) - v) != size)
412: panic("startup: table size inconsistency");
413:
414: /*
415: * Determine how many buffers to allocate.
416: * We allocate bufcachepercent% of memory for buffer space.
417: */
418: if (bufpages == 0)
419: bufpages = physmem * bufcachepercent / 100;
420:
421: /* Restrict to at most 25% filled kvm */
422: if (bufpages >
423: (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) / PAGE_SIZE / 4)
424: bufpages = (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) /
425: PAGE_SIZE / 4;
426:
427: /*
428: * Allocate a submap for exec arguments. This map effectively
429: * limits the number of processes exec'ing at any time.
430: */
431: minaddr = vm_map_min(kernel_map);
432: exec_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
433: 16 * NCARGS, VM_MAP_PAGEABLE, FALSE, NULL);
434:
435: /*
436: * Allocate a submap for physio
437: */
438: phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
439: VM_PHYS_SIZE, 0, FALSE, NULL);
440:
441: printf("avail mem = %lu (%luMB)\n", ptoa(uvmexp.free),
442: ptoa(uvmexp.free) / 1024 / 1024);
443:
444: /*
445: * Set up CPU-specific registers, cache, etc.
446: */
447: initcpu();
448:
449: /*
450: * Set up buffers, so they can be used to read disk labels.
451: */
452: bufinit();
453:
454: /*
455: * Configure the system.
456: */
457: if (boothowto & RB_CONFIG) {
458: #ifdef BOOT_CONFIG
459: user_config();
460: #else
461: printf("kernel does not support -c; continuing..\n");
462: #endif
463: }
464:
465: /* Safe for extent allocation to use malloc now. */
466: iomem_malloc_safe = 1;
467: }
468:
469: /*
470: * Allocate space for system data structures. We are given
471: * a starting virtual address and we return a final virtual
472: * address; along the way we set each data structure pointer.
473: *
474: * We call allocsys() with 0 to find out how much space we want,
475: * allocate that much and fill it with zeroes, and then call
476: * allocsys() again with the correct base virtual address.
477: */
478: caddr_t
479: allocsys(v)
480: caddr_t v;
481: {
482:
483: #define valloc(name, type, num) \
484: (name) = (type *)v; v = (caddr_t)((name)+(num))
485: #define valloclim(name, type, num, lim) \
486: (name) = (type *)v; v = (caddr_t)((lim) = ((name)+(num)))
487:
488: #ifdef SYSVMSG
489: valloc(msgpool, char, msginfo.msgmax);
490: valloc(msgmaps, struct msgmap, msginfo.msgseg);
491: valloc(msghdrs, struct msg, msginfo.msgtql);
492: valloc(msqids, struct msqid_ds, msginfo.msgmni);
493: #endif
494:
495: return (v);
496: }
497:
498: void
499: initcpu()
500: {
501: #if defined(M68040)
502: extern void (*vectab[256])(void);
503: void addrerr4060(void);
504: #endif
505: #ifdef M68040
506: void buserr40(void);
507: #endif
508: #ifdef FPSP
509: extern u_long fpvect_tab, fpvect_end, fpsp_tab;
510: #endif
511:
512: switch (cputype) {
513: #ifdef M68040
514: case CPU_68040:
515: vectab[2] = buserr40;
516: vectab[3] = addrerr4060;
517: #ifdef FPSP
518: bcopy(&fpsp_tab, &fpvect_tab,
519: (&fpvect_end - &fpvect_tab) * sizeof (fpvect_tab));
520: #endif
521: break;
522: #endif
523: default:
524: break;
525: }
526:
527: DCIS();
528: }
529:
530: void doboot(void)
531: __attribute__((__noreturn__));
532:
533: int waittime = -1;
534:
535: void
536: boot(howto)
537: int howto;
538: {
539: extern u_long maxaddr;
540:
541: /* take a snap shot before clobbering any registers */
542: if (curproc && curproc->p_addr)
543: savectx(&curproc->p_addr->u_pcb);
544:
545: /* If system is cold, just halt. */
546: if (cold) {
547: /* (Unless the user explicitly asked for reboot.) */
548: if ((howto & RB_USERREQ) == 0)
549: howto |= RB_HALT;
550: goto haltsys;
551: }
552:
553: boothowto = howto;
554: if ((howto & RB_NOSYNC) == 0 && waittime < 0) {
555: waittime = 0;
556: vfs_shutdown();
557:
558: if (mac68k_machine.aux_interrupts != 0) {
559: /*
560: * If we've been adjusting the clock, the todr
561: * will be out of synch; adjust it now unless
562: * the system was sitting in ddb.
563: */
564: if ((howto & RB_TIMEBAD) == 0) {
565: resettodr();
566: } else {
567: printf("WARNING: not updating battery clock\n");
568: }
569: } else {
570: #ifdef DIAGNOSTIC
571: printf("OpenBSD/mac68k does not trust itself to update"
572: " the clock on shutdown on this machine.\n");
573: #endif
574: }
575: }
576:
577: /* Disable interrupts. */
578: splhigh();
579:
580: /* If rebooting and a dump is requested, do it. */
581: if (howto & RB_DUMP) {
582: dumpsys();
583: }
584:
585: haltsys:
586: /* Run any shutdown hooks. */
587: doshutdownhooks();
588:
589: if (howto & RB_HALT) {
590: if (howto & RB_POWERDOWN) {
591: printf("\nAttempting to power down...\n");
592: via_powerdown();
593: /*
594: * Shut down machines whose power functions
595: * are accessed via modified ADB calls.
596: */
597: adb_poweroff();
598: }
599: printf("\nThe operating system has halted.\n");
600: printf("Please press any key to reboot.\n\n");
601: (void)cngetc();
602: }
603:
604: /* Map the last physical page VA = PA for doboot() */
605: pmap_enter(pmap_kernel(), (vaddr_t)maxaddr, (vaddr_t)maxaddr,
606: VM_PROT_ALL, VM_PROT_ALL|PMAP_WIRED);
607: pmap_update(pmap_kernel());
608:
609: printf("rebooting...\n");
610: DELAY(1000000);
611: doboot();
612: /* NOTREACHED */
613: }
614:
615: /*
616: * Initialize the kernel crash dump header.
617: */
618: void
619: cpu_init_kcore_hdr()
620: {
621: cpu_kcore_hdr_t *h = &cpu_kcore_hdr;
622: int i;
623:
624: bzero(&cpu_kcore_hdr, sizeof(cpu_kcore_hdr));
625:
626: h->mmutype = mmutype;
627: h->kernel_pa = low[0];
628: h->sysseg_pa = pmap_kernel()->pm_stpa;
629:
630: /*
631: * mac68k has multiple RAM segments on some models.
632: */
633: for (i = 0; i < numranges; i++) {
634: h->ram_segs[i].start = low[i];
635: h->ram_segs[i].size = high[i] - low[i];
636: }
637: }
638:
639: /*
640: * Compute the size of the machine-dependent crash dump header.
641: * Returns size in disk blocks.
642: */
643: int
644: cpu_dumpsize()
645: {
646: int size;
647:
648: size = ALIGN(sizeof(kcore_seg_t)) + ALIGN(sizeof(cpu_kcore_hdr_t));
649: return (btodb(roundup(size, dbtob(1))));
650: }
651:
652: /*
653: * Called by dumpsys() to dump the machine-dependent header.
654: */
655: int
656: cpu_dump(dump, blknop)
657: int (*dump)(dev_t, daddr64_t, caddr_t, size_t);
658: daddr64_t *blknop;
659: {
660: int buf[dbtob(1) / sizeof(int)];
661: cpu_kcore_hdr_t *chdr;
662: kcore_seg_t *kseg;
663: int error;
664:
665: kseg = (kcore_seg_t *)buf;
666: chdr = (cpu_kcore_hdr_t *)&buf[ALIGN(sizeof(kcore_seg_t)) /
667: sizeof(int)];
668:
669: /* Create the segment header. */
670: CORE_SETMAGIC(*kseg, KCORE_MAGIC, MID_MACHINE, CORE_CPU);
671: kseg->c_size = dbtob(1) - ALIGN(sizeof(kcore_seg_t));
672:
673: bcopy(&cpu_kcore_hdr, chdr, sizeof(cpu_kcore_hdr_t));
674: error = (*dump)(dumpdev, *blknop, (caddr_t)buf, sizeof(buf));
675: *blknop += btodb(sizeof(buf));
676: return (error);
677: }
678:
679: /*
680: * These variables are needed by /sbin/savecore
681: */
682: u_long dumpmag = 0x8fca0101; /* magic number */
683: int dumpsize = 0; /* pages */
684: long dumplo = 0; /* blocks */
685:
686: /*
687: * This is called by main to set dumplo and dumpsize.
688: * Dumps always skip the first block of disk space in
689: * case there might be a disk label stored there. If there
690: * is extra space, put dump at the end to reduce the chance
691: * that swapping trashes it.
692: */
693: void
694: dumpconf(void)
695: {
696: cpu_kcore_hdr_t *h = &cpu_kcore_hdr;
697: int nblks; /* size of dump area */
698: int i;
699:
700: if (dumpdev == NODEV ||
701: (nblks = (bdevsw[major(dumpdev)].d_psize)(dumpdev)) == 0)
702: return;
703: if (nblks <= ctod(1))
704: return;
705:
706: dumpsize = 0;
707: for (i = 0; h->ram_segs[i].size && i < NPHYS_RAM_SEGS; i++)
708: dumpsize += btoc(h->ram_segs[i].size);
709: dumpsize += cpu_dumpsize();
710:
711: /* Always skip the first block, in case there is a label there. */
712: if (dumplo < ctod(1))
713: dumplo = ctod(1);
714:
715: /* Put dump at end of partition, and make it fit. */
716: if (dumpsize > dtoc(nblks - dumplo))
717: dumpsize = dtoc(nblks - dumplo);
718: if (dumplo < nblks - ctod(dumpsize))
719: dumplo = nblks - ctod(dumpsize);
720: }
721:
722: void
723: dumpsys()
724: {
725: cpu_kcore_hdr_t *h = &cpu_kcore_hdr;
726: daddr64_t blkno; /* current block to write */
727: /* dump routine */
728: int (*dump)(dev_t, daddr64_t, caddr_t, size_t);
729: int pg; /* page being dumped */
730: vaddr_t maddr; /* PA being dumped */
731: int seg; /* RAM segment being dumped */
732: int error; /* error code from (*dump)() */
733: extern int msgbufmapped;
734:
735: /* XXX initialized here because of gcc lossage */
736: seg = 0;
737: maddr = h->ram_segs[seg].start;
738: pg = 0;
739:
740: /* Don't record dump msgs in msgbuf. */
741: msgbufmapped = 0;
742:
743: /* Make sure dump device is valid. */
744: if (dumpdev == NODEV)
745: return;
746: if (dumpsize == 0) {
747: dumpconf();
748: if (dumpsize == 0)
749: return;
750: }
751: if (dumplo <= 0) {
752: printf("\ndump to dev %u,%u not possible\n", major(dumpdev),
753: minor(dumpdev));
754: return;
755: }
756: dump = bdevsw[major(dumpdev)].d_dump;
757: blkno = dumplo;
758:
759: printf("\ndumping to dev %u,%u offset %ld\n", major(dumpdev),
760: minor(dumpdev), dumplo);
761:
762: printf("dump ");
763:
764: /* Write the dump header. */
765: error = cpu_dump(dump, &blkno);
766: if (error)
767: goto bad;
768:
769: for (pg = 0; pg < dumpsize; pg++) {
770: #define NPGMB (1024*1024/NBPG)
771: /* print out how many MBs we have dumped */
772: if (pg && (pg % NPGMB) == 0)
773: printf("%d ", pg / NPGMB);
774: #undef NPGMB
775: while (maddr >=
776: (h->ram_segs[seg].start + h->ram_segs[seg].size)) {
777: if (++seg >= NPHYS_RAM_SEGS ||
778: h->ram_segs[seg].size == 0) {
779: error = EINVAL; /* XXX ?? */
780: goto bad;
781: }
782: maddr = h->ram_segs[seg].start;
783: }
784: pmap_enter(pmap_kernel(), (vaddr_t)vmmap, maddr,
785: VM_PROT_READ, VM_PROT_READ|PMAP_WIRED);
786: pmap_update(pmap_kernel());
787:
788: error = (*dump)(dumpdev, blkno, vmmap, NBPG);
789: bad:
790: switch (error) {
791: case 0:
792: maddr += NBPG;
793: blkno += btodb(NBPG);
794: break;
795:
796: case ENXIO:
797: printf("device bad\n");
798: return;
799:
800: case EFAULT:
801: printf("device not ready\n");
802: return;
803:
804: case EINVAL:
805: printf("area improper\n");
806: return;
807:
808: case EIO:
809: printf("i/o error\n");
810: return;
811:
812: case EINTR:
813: printf("aborted from console\n");
814: return;
815:
816: default:
817: printf("error %d\n", error);
818: return;
819: }
820: }
821: printf("succeeded\n");
822: }
823:
824: /*
825: * Return the best possible estimate of the time in the timeval
826: * to which tvp points. We do this by returning the current time
827: * plus the amount of time since the last clock interrupt (clock.c:clkread).
828: *
829: * Check that this time is no less than any previously-reported time,
830: * which could happen around the time of a clock adjustment. Just for fun,
831: * we guarantee that the time will be greater than the value obtained by a
832: * previous call.
833: */
834: void
835: microtime(tvp)
836: register struct timeval *tvp;
837: {
838: int s = splhigh();
839: static struct timeval lasttime;
840:
841: *tvp = time;
842: tvp->tv_usec += clkread();
843: while (tvp->tv_usec >= 1000000) {
844: tvp->tv_sec++;
845: tvp->tv_usec -= 1000000;
846: }
847: if (tvp->tv_sec == lasttime.tv_sec &&
848: tvp->tv_usec <= lasttime.tv_usec &&
849: (tvp->tv_usec = lasttime.tv_usec + 1) >= 1000000) {
850: tvp->tv_sec++;
851: tvp->tv_usec -= 1000000;
852: }
853: lasttime = *tvp;
854: splx(s);
855: }
856:
857: void
858: straytrap(pc, evec)
859: int pc;
860: int evec;
861: {
862: printf("unexpected trap; vector offset 0x%x from 0x%x.\n",
863: (int) (evec & 0xfff), pc);
864: #ifdef DEBUG
865: #ifdef DDB
866: Debugger();
867: #endif
868: #endif
869: }
870:
871: int *nofault;
872:
873: /*
874: * Level 7 interrupts can be caused by the keyboard or parity errors.
875: */
876: void nmihand(struct frame);
877:
878: void
879: nmihand(frame)
880: struct frame frame;
881: {
882: static int nmihanddeep = 0;
883:
884: if (nmihanddeep)
885: return;
886: nmihanddeep = 1;
887:
888: #ifdef DDB
889: if (db_console)
890: Debugger();
891: #endif
892:
893: nmihanddeep = 0;
894: }
895:
896: /*
897: * It should be possible to probe for the top of RAM, but Apple has
898: * memory structured so that in at least some cases, it's possible
899: * for RAM to be aliased across all memory--or for it to appear that
900: * there is more RAM than there really is.
901: */
902: int get_top_of_ram(void);
903:
904: int
905: get_top_of_ram()
906: {
907: return ((mac68k_machine.mach_memsize * (1024 * 1024)) - 4096);
908: }
909:
910: /*
911: * machine dependent system variables.
912: */
913: int
914: cpu_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
915: int *name;
916: u_int namelen;
917: void *oldp;
918: size_t *oldlenp;
919: void *newp;
920: size_t newlen;
921: struct proc *p;
922: {
923: dev_t consdev;
924:
925: /* all sysctl names at this level are terminal */
926: if (namelen != 1)
927: return (ENOTDIR); /* overloaded */
928:
929: switch (name[0]) {
930: case CPU_CONSDEV:
931: if (cn_tab != NULL)
932: consdev = cn_tab->cn_dev;
933: else
934: consdev = NODEV;
935: return (sysctl_rdstruct(oldp, oldlenp, newp, &consdev,
936: sizeof consdev));
937: default:
938: return (EOPNOTSUPP);
939: }
940: /* NOTREACHED */
941: }
942:
943: int
944: cpu_exec_aout_makecmds(p, epp)
945: struct proc *p;
946: struct exec_package *epp;
947: {
948: int error = ENOEXEC;
949:
950: #ifdef COMPAT_SUNOS
951: {
952: extern int sunos_exec_aout_makecmds(struct proc *,
953: struct exec_package *);
954: if ((error = sunos_exec_aout_makecmds(p, epp)) == 0)
955: return 0;
956: }
957: #endif
958: return error;
959: }
960:
961: static char *envbuf = NULL;
962:
963: /*
964: * getenvvars: Grab a few useful variables
965: */
966: void getenvvars(u_long, char *);
967: long getenv(char *);
968:
969: void
970: getenvvars(flag, buf)
971: u_long flag;
972: char *buf;
973: {
974: extern u_long bootdev;
975: #if defined(DDB) || NKSYMS > 0
976: extern u_long end, esym;
977: #endif
978: extern u_long macos_boottime;
979: extern vaddr_t MacOSROMBase;
980: extern long macos_gmtbias;
981: extern u_short ADBDelay;
982: extern u_int32_t HwCfgFlags3;
983: int root_scsi_id;
984: vaddr_t ROMBase;
985:
986: /*
987: * If flag & 0x80000000 == 0, then we're booting with the old booter
988: * and we should freak out.
989: */
990: if ((flag & 0x80000000) == 0) {
991: /* Freak out; print something if that becomes available */
992: } else
993: envbuf = buf;
994:
995: /* These next two should give us mapped video & serial */
996: /* We need these for pre-mapping graybars & echo, but probably */
997: /* only on MacII or LC. -- XXX */
998: /* videoaddr = getenv("MACOS_VIDEO"); */
999:
1000: /*
1001: * The following are not in a structure so that they can be
1002: * accessed more quickly.
1003: */
1004: videoaddr = getenv("VIDEO_ADDR");
1005: videorowbytes = getenv("ROW_BYTES");
1006: videobitdepth = getenv("SCREEN_DEPTH");
1007: videosize = getenv("DIMENSIONS");
1008:
1009: /*
1010: * More misc stuff from booter.
1011: */
1012: mac68k_machine.machineid = getenv("MACHINEID");
1013: mac68k_machine.mach_memsize = getenv("MEMSIZE");
1014: mac68k_machine.do_graybars = getenv("GRAYBARS");
1015: mac68k_machine.serial_boot_echo = getenv("SERIALECHO");
1016: mac68k_machine.serial_console = getenv("SERIALCONSOLE");
1017:
1018: mac68k_machine.modem_flags = getenv("SERIAL_MODEM_FLAGS");
1019: mac68k_machine.modem_cts_clk = getenv("SERIAL_MODEM_HSKICLK");
1020: mac68k_machine.modem_dcd_clk = getenv("SERIAL_MODEM_GPICLK");
1021: mac68k_machine.modem_flags = getenv("SERIAL_MODEM_DSPEED");
1022: mac68k_machine.print_flags = getenv("SERIAL_PRINT_FLAGS");
1023: mac68k_machine.print_cts_clk = getenv("SERIAL_PRINT_HSKICLK");
1024: mac68k_machine.print_dcd_clk = getenv("SERIAL_PRINT_GPICLK");
1025: mac68k_machine.print_d_speed = getenv("SERIAL_PRINT_DSPEED");
1026: mac68k_machine.booter_version = getenv("BOOTERVER");
1027:
1028: /*
1029: * For now, we assume that the boot device is off the first controller.
1030: * Booter versions 1.11.0 and later set a flag to tell us to construct
1031: * bootdev using the SCSI ID passed in via the environment.
1032: */
1033: root_scsi_id = getenv("ROOT_SCSI_ID");
1034: if (((mac68k_machine.booter_version < CURRENTBOOTERVER) ||
1035: (flag & 0x40000)) && bootdev == 0)
1036: bootdev = MAKEBOOTDEV(4, 0, 0, root_scsi_id, 0);
1037:
1038: /*
1039: * Booter 1.11.3 and later pass a BOOTHOWTO variable with the
1040: * appropriate bits set.
1041: */
1042: boothowto = getenv("BOOTHOWTO");
1043: if (boothowto == 0)
1044: boothowto = getenv("SINGLE_USER");
1045:
1046: /*
1047: * Get end of symbols for kernel debugging
1048: */
1049: #if defined(DDB) || NKSYMS > 0
1050: esym = getenv("END_SYM");
1051: if (esym == 0)
1052: esym = (long) &end;
1053: #endif
1054:
1055: /* Get MacOS time */
1056: macos_boottime = getenv("BOOTTIME");
1057:
1058: /* Save GMT BIAS saved in Booter parameters dialog box */
1059: macos_gmtbias = getenv("GMTBIAS");
1060:
1061: /*
1062: * Save globals stolen from MacOS
1063: */
1064:
1065: ROMBase = (vaddr_t)getenv("ROMBASE");
1066: if (ROMBase != 0)
1067: MacOSROMBase = ROMBase;
1068: ADBDelay = (u_short) getenv("ADBDELAY");
1069: HwCfgFlags3 = getenv("HWCFGFLAG3");
1070: }
1071:
1072: char toupper(char);
1073:
1074: char
1075: toupper(c)
1076: char c;
1077: {
1078: if (c >= 'a' && c <= 'z') {
1079: return c - 'a' + 'A';
1080: } else {
1081: return c;
1082: }
1083: }
1084:
1085: long
1086: getenv(str)
1087: char *str;
1088: {
1089: /*
1090: * Returns the value of the environment variable "str".
1091: *
1092: * Format of the buffer is "var=val\0var=val\0...\0var=val\0\0".
1093: *
1094: * Returns 0 if the variable is not there, and 1 if the variable is
1095: * there without an "=val".
1096: */
1097:
1098: char *s, *s1;
1099: int val, base;
1100:
1101: s = envbuf;
1102: while (1) {
1103: for (s1 = str; *s1 && *s && *s != '='; s1++, s++) {
1104: if (toupper(*s1) != toupper(*s)) {
1105: break;
1106: }
1107: }
1108: if (*s1) { /* No match */
1109: while (*s) {
1110: s++;
1111: }
1112: s++;
1113: if (*s == '\0') { /* Not found */
1114: /* Boolean flags are FALSE (0) if not there */
1115: return 0;
1116: }
1117: continue;
1118: }
1119: if (*s == '=') {/* Has a value */
1120: s++;
1121: val = 0;
1122: base = 10;
1123: if (*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')) {
1124: base = 16;
1125: s += 2;
1126: } else
1127: if (*s == '0') {
1128: base = 8;
1129: }
1130: while (*s) {
1131: if (toupper(*s) >= 'A' && toupper(*s) <= 'F') {
1132: val = val * base + toupper(*s) - 'A' + 10;
1133: } else {
1134: val = val * base + (*s - '0');
1135: }
1136: s++;
1137: }
1138: return val;
1139: } else { /* TRUE (1) */
1140: return 1;
1141: }
1142: }
1143: }
1144:
1145: struct cpu_model_info cpu_models[] = {
1146:
1147: /* The first four. */
1148: { MACH_MACII, "II", MACH_CLASSII },
1149: { MACH_MACIIX, "IIx", MACH_CLASSII },
1150: { MACH_MACIICX, "IIcx", MACH_CLASSII },
1151: { MACH_MACSE30, "SE/30", MACH_CLASSII },
1152:
1153: /* The rest of the II series... */
1154: { MACH_MACIICI, "IIci", MACH_CLASSIIci },
1155: { MACH_MACIISI, "IIsi", MACH_CLASSIIsi },
1156: { MACH_MACIIVI, "IIvi", MACH_CLASSIIvx },
1157: { MACH_MACIIVX, "IIvx", MACH_CLASSIIvx },
1158: { MACH_MACIIFX, "IIfx", MACH_CLASSIIfx },
1159:
1160: /* The Centris/Quadra series. */
1161: { MACH_MACQ700, "Quadra 700", MACH_CLASSQ },
1162: { MACH_MACQ900, "Quadra 900", MACH_CLASSQ },
1163: { MACH_MACQ950, "Quadra 950", MACH_CLASSQ },
1164: { MACH_MACQ800, "Quadra 800", MACH_CLASSQ },
1165: { MACH_MACQ650, "Quadra 650", MACH_CLASSQ },
1166: { MACH_MACC650, "Centris 650", MACH_CLASSQ },
1167: { MACH_MACQ605, "Quadra 605", MACH_CLASSQ },
1168: { MACH_MACQ605_33, "Quadra 605/33", MACH_CLASSQ },
1169: { MACH_MACC610, "Centris 610", MACH_CLASSQ },
1170: { MACH_MACQ610, "Quadra 610", MACH_CLASSQ },
1171: { MACH_MACQ630, "Quadra 630", MACH_CLASSQ2 },
1172: { MACH_MACC660AV, "Centris 660AV", MACH_CLASSAV },
1173: { MACH_MACQ840AV, "Quadra 840AV", MACH_CLASSAV },
1174:
1175: /* The Powerbooks/Duos... */
1176: { MACH_MACPB100, "PowerBook 100", MACH_CLASSPB },
1177: /* PB 100 has no MMU! */
1178: { MACH_MACPB140, "PowerBook 140", MACH_CLASSPB },
1179: { MACH_MACPB145, "PowerBook 145", MACH_CLASSPB },
1180: { MACH_MACPB150, "PowerBook 150", MACH_CLASSDUO },
1181: { MACH_MACPB160, "PowerBook 160", MACH_CLASSPB },
1182: { MACH_MACPB165, "PowerBook 165", MACH_CLASSPB },
1183: { MACH_MACPB165C, "PowerBook 165c", MACH_CLASSPB },
1184: { MACH_MACPB170, "PowerBook 170", MACH_CLASSPB },
1185: { MACH_MACPB180, "PowerBook 180", MACH_CLASSPB },
1186: { MACH_MACPB180C, "PowerBook 180c", MACH_CLASSPB },
1187: { MACH_MACPB190, "PowerBook 190", MACH_CLASSPB },
1188: { MACH_MACPB190CS, "PowerBook 190cs", MACH_CLASSPB },
1189: { MACH_MACPB500, "PowerBook 500", MACH_CLASSPB },
1190:
1191: /* The Duos */
1192: { MACH_MACPB210, "PowerBook Duo 210", MACH_CLASSDUO },
1193: { MACH_MACPB230, "PowerBook Duo 230", MACH_CLASSDUO },
1194: { MACH_MACPB250, "PowerBook Duo 250", MACH_CLASSDUO },
1195: { MACH_MACPB270, "PowerBook Duo 270C", MACH_CLASSDUO },
1196: { MACH_MACPB280, "PowerBook Duo 280", MACH_CLASSDUO },
1197: { MACH_MACPB280C, "PowerBook Duo 280C", MACH_CLASSDUO },
1198:
1199: /* The Performas... */
1200: { MACH_MACP600, "Performa 600", MACH_CLASSIIvx },
1201: { MACH_MACP460, "Performa 460", MACH_CLASSLC },
1202: { MACH_MACP550, "Performa 550", MACH_CLASSLC },
1203: { MACH_MACP580, "Performa 580", MACH_CLASSQ2 },
1204: { MACH_MACTV, "TV", MACH_CLASSLC },
1205:
1206: /* The LCs... */
1207: { MACH_MACLCII, "LC II", MACH_CLASSLC },
1208: { MACH_MACLCIII, "LC III", MACH_CLASSLC },
1209: { MACH_MACLC475, "LC 475", MACH_CLASSQ },
1210: { MACH_MACLC475_33, "LC 475/33", MACH_CLASSQ },
1211: { MACH_MACLC520, "LC 520", MACH_CLASSLC },
1212: { MACH_MACLC575, "LC 575", MACH_CLASSQ2 },
1213: { MACH_MACCCLASSIC, "Color Classic", MACH_CLASSLC },
1214: { MACH_MACCCLASSICII, "Color ClassicII", MACH_CLASSLC },
1215: /* Does this belong here? */
1216: { MACH_MACCLASSICII, "Classic II", MACH_CLASSLC },
1217:
1218: /* The unknown one and the end... */
1219: { 0, "Unknown", MACH_CLASSII }
1220: }; /* End of cpu_models[] initialization. */
1221:
1222: struct intvid_info_t {
1223: int machineid;
1224: u_long fbbase;
1225: u_long fbmask;
1226: u_long fblen;
1227: } intvid_info[] = {
1228: { MACH_MACCLASSICII, 0x009f9a80, 0x0, 21888 },
1229: { MACH_MACPB140, 0xfee08000, 0x0, 32 * 1024 },
1230: { MACH_MACPB145, 0xfee08000, 0x0, 32 * 1024 },
1231: { MACH_MACPB170, 0xfee08000, 0x0, 32 * 1024 },
1232: { MACH_MACPB150, 0x60000000, 0x0, 128 * 1024 },
1233: { MACH_MACPB160, 0x60000000, 0x0ffe0000, 128 * 1024 },
1234: { MACH_MACPB165, 0x60000000, 0x0ffe0000, 128 * 1024 },
1235: { MACH_MACPB180, 0x60000000, 0x0ffe0000, 128 * 1024 },
1236: { MACH_MACPB210, 0x60000000, 0x0, 128 * 1024 },
1237: { MACH_MACPB230, 0x60000000, 0x0, 128 * 1024 },
1238: { MACH_MACPB250, 0x60000000, 0x0, 128 * 1024 },
1239: { MACH_MACPB270, 0x60000000, 0x0, 128 * 1024 },
1240: { MACH_MACPB280, 0x60000000, 0x0, 128 * 1024 },
1241: { MACH_MACPB280C, 0x60000000, 0x0, 128 * 1024 },
1242: { MACH_MACIICI, 0x0, 0x0, 320 * 1024 },
1243: { MACH_MACIISI, 0x0, 0x0, 320 * 1024 },
1244: { MACH_MACCCLASSIC, 0x50f40000, 0x0, 512 * 1024 },
1245: /*??*/ { MACH_MACLCII, 0x50f40000, 0x0, 512 * 1024 },
1246: { MACH_MACPB165C, 0xfc040000, 0x0, 512 * 1024 },
1247: { MACH_MACPB180C, 0xfc040000, 0x0, 512 * 1024 },
1248: { MACH_MACPB190, 0x60000000, 0x0, 512 * 1024 },
1249: { MACH_MACPB190CS, 0x60000000, 0x0, 512 * 1024 },
1250: { MACH_MACPB500, 0x60000000, 0x0, 512 * 1024 },
1251: { MACH_MACLCIII, 0x60b00000, 0x0, 768 * 1024 },
1252: { MACH_MACLC520, 0x60000000, 0x0, 1024 * 1024 },
1253: { MACH_MACP550, 0x60000000, 0x0, 1024 * 1024 },
1254: { MACH_MACTV, 0x60000000, 0x0, 1024 * 1024 },
1255: { MACH_MACLC475, 0xf9000000, 0x0, 1024 * 1024 },
1256: { MACH_MACLC475_33, 0xf9000000, 0x0, 1024 * 1024 },
1257: { MACH_MACLC575, 0xf9000000, 0x0, 1024 * 1024 },
1258: { MACH_MACC610, 0xf9000000, 0x0, 1024 * 1024 },
1259: { MACH_MACC650, 0xf9000000, 0x0, 1024 * 1024 },
1260: { MACH_MACP580, 0xf9000000, 0x0, 1024 * 1024 },
1261: { MACH_MACQ605, 0xf9000000, 0x0, 1024 * 1024 },
1262: { MACH_MACQ605_33, 0xf9000000, 0x0, 1024 * 1024 },
1263: { MACH_MACQ610, 0xf9000000, 0x0, 1024 * 1024 },
1264: { MACH_MACQ630, 0xf9000000, 0x0, 1024 * 1024 },
1265: { MACH_MACQ650, 0xf9000000, 0x0, 1024 * 1024 },
1266: { MACH_MACC660AV, 0x50100000, 0x0, 1024 * 1024 },
1267: { MACH_MACQ700, 0xf9000000, 0x0, 1024 * 1024 },
1268: { MACH_MACQ800, 0xf9000000, 0x0, 1024 * 1024 },
1269: { MACH_MACQ900, 0xf9000000, 0x0, 1024 * 1024 },
1270: { MACH_MACQ950, 0xf9000000, 0x0, 1024 * 1024 },
1271: { MACH_MACQ840AV, 0x50100000, 0x0, 2048 * 1024 },
1272: { 0, 0x0, 0x0, 0 },
1273: }; /* End of intvid_info[] initialization. */
1274:
1275: /*
1276: * Missing Mac Models:
1277: * PowerMac 6100
1278: * PowerMac 7100
1279: * PowerMac 8100
1280: * PowerBook 540
1281: * PowerBook 520
1282: * PowerBook 150
1283: * Duo 280
1284: * Performa 6000s
1285: * ...?
1286: */
1287:
1288: char cpu_model[120]; /* for sysctl() */
1289:
1290: int
1291: fpu_probe()
1292: {
1293: /*
1294: * A 68881 idle frame is 28 bytes and a 68882's is 60 bytes.
1295: * We, of course, need to have enough room for either.
1296: */
1297: int fpframe[60 / sizeof(int)];
1298: label_t faultbuf;
1299: u_char b;
1300:
1301: nofault = (int *) &faultbuf;
1302: if (setjmp(&faultbuf)) {
1303: nofault = (int *) 0;
1304: return (FPU_NONE);
1305: }
1306:
1307: /*
1308: * Synchronize FPU or cause a fault.
1309: * This should leave the 881/882 in the IDLE state,
1310: * state, so we can determine which we have by
1311: * examining the size of the FP state frame
1312: */
1313: asm("fnop");
1314:
1315: nofault = (int *) 0;
1316:
1317: /*
1318: * Presumably, if we're an 040 and did not take exception
1319: * above, we have an FPU. Don't bother probing.
1320: */
1321: if (mmutype == MMU_68040)
1322: return (FPU_68040);
1323:
1324: /*
1325: * Presumably, this will not cause a fault--the fnop should
1326: * have if this will. We save the state in order to get the
1327: * size of the frame.
1328: */
1329: asm("movl %0, a0; fsave a0@" : : "a" (fpframe) : "a0" );
1330:
1331: b = *((u_char *) fpframe + 1);
1332:
1333: /*
1334: * Now, restore a NULL state to reset the FPU.
1335: */
1336: fpframe[0] = fpframe[1] = 0;
1337: m68881_restore((struct fpframe *) fpframe);
1338:
1339: /*
1340: * The size of a 68881 IDLE frame is 0x18
1341: * and a 68882 frame is 0x38
1342: */
1343: if (b == 0x18)
1344: return (FPU_68881);
1345: if (b == 0x38)
1346: return (FPU_68882);
1347:
1348: /*
1349: * If it's not one of the above, we have no clue what it is.
1350: */
1351: return (FPU_UNKNOWN);
1352: }
1353:
1354: void
1355: identifycpu()
1356: {
1357: #ifdef DEBUG
1358: extern u_int delay_factor;
1359: #endif
1360:
1361: /*
1362: * Print the machine type...
1363: */
1364: snprintf(cpu_model, sizeof cpu_model, "Apple Macintosh %s",
1365: cpu_models[mac68k_machine.cpu_model_index].model);
1366:
1367: /*
1368: * ... and the CPU type...
1369: */
1370: switch (cputype) {
1371: case CPU_68040:
1372: strlcat(cpu_model, ", 68040 CPU", sizeof cpu_model);
1373: break;
1374: case CPU_68030:
1375: strlcat(cpu_model, ", 68030 CPU", sizeof cpu_model);
1376: break;
1377: case CPU_68020:
1378: strlcat(cpu_model, ", 68020 CPU", sizeof cpu_model);
1379: break;
1380: default:
1381: strlcat(cpu_model, ", unknown CPU", sizeof cpu_model);
1382: break;
1383: }
1384:
1385: /*
1386: * ... and the MMU type...
1387: */
1388: switch (mmutype) {
1389: case MMU_68040:
1390: case MMU_68030:
1391: strlcat(cpu_model, "+MMU", sizeof cpu_model);
1392: break;
1393: case MMU_68851:
1394: strlcat(cpu_model, ", MC68851 MMU", sizeof cpu_model);
1395: break;
1396: default:
1397: printf("%s\n", cpu_model);
1398: panic("unknown MMU type %d", mmutype);
1399: /* NOTREACHED */
1400: }
1401:
1402: /*
1403: * ... and the FPU type...
1404: */
1405: fputype = fpu_probe(); /* should eventually move to locore */
1406:
1407: switch (fputype) {
1408: case FPU_68040:
1409: strlcat(cpu_model, "+FPU", sizeof cpu_model);
1410: break;
1411: case FPU_68882:
1412: strlcat(cpu_model, ", MC6882 FPU", sizeof cpu_model);
1413: break;
1414: case FPU_68881:
1415: strlcat(cpu_model, ", MC6881 FPU", sizeof cpu_model);
1416: break;
1417: case FPU_UNKNOWN:
1418: strlcat(cpu_model, ", unknown FPU", sizeof cpu_model);
1419: break;
1420: default:
1421: /*strlcat(cpu_model, ", no FPU", sizeof cpu_model);*/
1422: break;
1423: }
1424:
1425: /*
1426: * ... and finally, the cache type.
1427: */
1428: if (cputype == CPU_68040)
1429: strlcat(cpu_model, ", 4k on-chip physical I/D caches", sizeof cpu_model);
1430:
1431: printf("%s\n", cpu_model);
1432: #ifdef DEBUG
1433: printf("cpu: delay factor %d\n", delay_factor);
1434: #endif
1435: }
1436:
1437: void get_machine_info(void);
1438:
1439: void
1440: get_machine_info()
1441: {
1442: int i;
1443:
1444: for (i = 0; cpu_models[i].machineid != 0; i++)
1445: if (mac68k_machine.machineid == cpu_models[i].machineid)
1446: break;
1447:
1448: mac68k_machine.cpu_model_index = i;
1449: }
1450:
1451: const struct cpu_model_info *current_mac_model;
1452:
1453: /*
1454: * Sets a bunch of machine-specific variables
1455: */
1456: void setmachdep(void);
1457:
1458: void
1459: setmachdep()
1460: {
1461: struct cpu_model_info *cpui;
1462:
1463: /*
1464: * First, set things that need to be set on the first pass only
1465: * Ideally, we'd only call this once, but for some reason, the
1466: * VIAs need interrupts turned off twice !?
1467: */
1468: get_machine_info();
1469:
1470: load_addr = 0;
1471: cpui = &(cpu_models[mac68k_machine.cpu_model_index]);
1472: current_mac_model = cpui;
1473:
1474: mac68k_machine.via1_ipl = 1;
1475: mac68k_machine.aux_interrupts = 0;
1476:
1477: /*
1478: * Set up any machine specific stuff that we have to before
1479: * ANYTHING else happens
1480: */
1481: switch (cpui->class) { /* Base this on class of machine... */
1482: case MACH_CLASSII:
1483: VIA2 = VIA2OFF;
1484: IOBase = 0x50f00000;
1485: Via1Base = (volatile u_char *)IOBase;
1486: mac68k_machine.scsi80 = 1;
1487: via_reg(VIA1, vIER) = 0x7f; /* disable VIA1 int */
1488: via_reg(VIA2, vIER) = 0x7f; /* disable VIA2 int */
1489: break;
1490: case MACH_CLASSPB:
1491: VIA2 = VIA2OFF;
1492: IOBase = 0x50f00000;
1493: Via1Base = (volatile u_char *)IOBase;
1494: mac68k_machine.scsi80 = 1;
1495: /* Disable everything but PM; we need it. */
1496: via_reg(VIA1, vIER) = 0x6f; /* disable VIA1 int */
1497: /* Are we disabling something important? */
1498: via_reg(VIA2, vIER) = 0x7f; /* disable VIA2 int */
1499: if (cputype == CPU_68040)
1500: mac68k_machine.sonic = 1;
1501: break;
1502: case MACH_CLASSDUO:
1503: /*
1504: * The Duo definitely does not use a VIA2, but it looks
1505: * like the VIA2 functions might be on the MSC at the RBV
1506: * locations. The rest is copied from the Powerbooks.
1507: */
1508: VIA2 = RBVOFF;
1509: IOBase = 0x50f00000;
1510: Via1Base = (volatile u_char *)IOBase;
1511: mac68k_machine.scsi80 = 1;
1512: /* Disable everything but PM; we need it. */
1513: via_reg(VIA1, vIER) = 0x6f; /* disable VIA1 int */
1514: /* Are we disabling something important? */
1515: via_reg(VIA2, rIER) = 0x7f; /* disable VIA2 int */
1516: break;
1517: case MACH_CLASSQ:
1518: case MACH_CLASSQ2:
1519: VIA2 = VIA2OFF;
1520: IOBase = 0x50f00000;
1521: Via1Base = (volatile u_char *)IOBase;
1522: mac68k_machine.sonic = 1;
1523: mac68k_machine.scsi96 = 1;
1524: via_reg(VIA1, vIER) = 0x7f; /* disable VIA1 int */
1525: via_reg(VIA2, vIER) = 0x7f; /* disable VIA2 int */
1526:
1527: /* Enable A/UX interrupt scheme */
1528: mac68k_machine.aux_interrupts = 1;
1529: via_reg(VIA1, vBufB) &= (0xff ^ DB1O_AuxIntEnb);
1530: via_reg(VIA1, vDirB) |= DB1O_AuxIntEnb;
1531: mac68k_machine.via1_ipl = 6;
1532:
1533: break;
1534: case MACH_CLASSAV:
1535: VIA2 = VIA2OFF;
1536: IOBase = 0x50f00000;
1537: Via1Base = (volatile u_char *)IOBase;
1538: mac68k_machine.scsi96 = 1;
1539: via_reg(VIA1, vIER) = 0x7f; /* disable VIA1 int */
1540: via_reg(VIA2, vIER) = 0x7f; /* disable VIA2 int */
1541: break;
1542: case MACH_CLASSIIci:
1543: VIA2 = RBVOFF;
1544: IOBase = 0x50f00000;
1545: Via1Base = (volatile u_char *)IOBase;
1546: mac68k_machine.scsi80 = 1;
1547: via_reg(VIA1, vIER) = 0x7f; /* disable VIA1 int */
1548: via_reg(VIA2, rIER) = 0x7f; /* disable RBV int */
1549: break;
1550: case MACH_CLASSIIsi:
1551: VIA2 = RBVOFF;
1552: IOBase = 0x50f00000;
1553: Via1Base = (volatile u_char *)IOBase;
1554: mac68k_machine.scsi80 = 1;
1555: via_reg(VIA1, vIER) = 0x7f; /* disable VIA1 int */
1556: via_reg(VIA2, rIER) = 0x7f; /* disable RBV int */
1557: break;
1558: case MACH_CLASSIIvx:
1559: VIA2 = RBVOFF;
1560: IOBase = 0x50f00000;
1561: Via1Base = (volatile u_char *)IOBase;
1562: mac68k_machine.scsi80 = 1;
1563: via_reg(VIA1, vIER) = 0x7f; /* disable VIA1 int */
1564: via_reg(VIA2, rIER) = 0x7f; /* disable RBV int */
1565: break;
1566: case MACH_CLASSLC:
1567: VIA2 = RBVOFF;
1568: IOBase = 0x50f00000;
1569: Via1Base = (volatile u_char *)IOBase;
1570: mac68k_machine.scsi80 = 1;
1571: via_reg(VIA1, vIER) = 0x7f; /* disable VIA1 int */
1572: via_reg(VIA2, rIER) = 0x7f; /* disable RBV int */
1573: break;
1574: case MACH_CLASSIIfx:
1575: VIA2 = OSSOFF;
1576: IOBase = 0x50f00000;
1577: Via1Base = (volatile u_char *)IOBase;
1578: mac68k_machine.scsi80 = 1;
1579: via_reg(VIA1, vIER) = 0x7f; /* disable VIA1 int */
1580: break;
1581: default:
1582: case MACH_CLASSH:
1583: break;
1584: }
1585: }
1586:
1587: /*
1588: * Set IO offsets.
1589: */
1590: void
1591: mac68k_set_io_offsets(base)
1592: vaddr_t base;
1593: {
1594: extern volatile u_char *sccA;
1595:
1596: switch (current_mac_model->class) {
1597: case MACH_CLASSQ:
1598: Via1Base = (volatile u_char *)base;
1599:
1600: /* The following two may be overriden. */
1601: sccA = (volatile u_char *)base + 0xc000;
1602: SCSIBase = base + 0xf000;
1603:
1604: switch (current_mac_model->machineid) {
1605: case MACH_MACQ900:
1606: case MACH_MACQ950:
1607: sccA = (volatile u_char *)base + 0xc020;
1608: iop_serial_compatible();
1609: mac68k_machine.scsi96_2 = 1;
1610: break;
1611: case MACH_MACQ700:
1612: break;
1613: default:
1614: SCSIBase = base + 0x10000;
1615: break;
1616: }
1617: break;
1618: case MACH_CLASSQ2:
1619: /*
1620: * Note the different offset for sccA for this class of
1621: * machines. This seems to be common on many of the
1622: * Quadra-type machines.
1623: */
1624: Via1Base = (volatile u_char *)base;
1625: sccA = (volatile u_char *)base + 0xc020;
1626: SCSIBase = base + 0x10000;
1627: break;
1628: case MACH_CLASSAV:
1629: Via1Base = (volatile u_char *)base;
1630: sccA = (volatile u_char *)base + 0x4000;
1631: SCSIBase = base + 0x18000;
1632: PSCBase = (volatile u_char *)base + 0x31000;
1633: break;
1634: case MACH_CLASSII:
1635: case MACH_CLASSPB:
1636: case MACH_CLASSDUO:
1637: case MACH_CLASSIIci:
1638: case MACH_CLASSIIsi:
1639: case MACH_CLASSIIvx:
1640: case MACH_CLASSLC:
1641: Via1Base = (volatile u_char *)base;
1642: sccA = (volatile u_char *)base + 0x4000;
1643: SCSIBase = base;
1644: break;
1645: case MACH_CLASSIIfx:
1646: Via1Base = (volatile u_char *)base;
1647: sccA = (volatile u_char *)base + 0x4020;
1648: iop_serial_compatible();
1649: SCSIBase = base;
1650: break;
1651: default:
1652: case MACH_CLASSH:
1653: panic("Unknown/unsupported machine class (%d).",
1654: current_mac_model->class);
1655: break;
1656: }
1657:
1658: Via2Base = Via1Base + 0x2000 * VIA2;
1659: }
1660:
1661: #if GRAYBARS
1662: u_long gray_nextaddr = 0;
1663:
1664: void
1665: gray_bar()
1666: {
1667: static int i = 0;
1668: static int flag = 0;
1669:
1670: /* MF basic premise as I see it:
1671: 1) Save the scratch regs as they are not saved by the compilier.
1672: 2) Check to see if we want gray bars, if so,
1673: display some lines of gray,
1674: a couple of lines of white(about 8),
1675: and loop to slow this down.
1676: 3) restore regs
1677: */
1678:
1679: __asm __volatile (" movl a0,sp@-;
1680: movl a1,sp@-;
1681: movl d0,sp@-;
1682: movl d1,sp@-");
1683:
1684: /* check to see if gray bars are turned off */
1685: if (mac68k_machine.do_graybars) {
1686: /* MF the 10*rowbytes/4 is done lots, but we want this to be
1687: * slow */
1688: for (i = 0; i < 10 * videorowbytes / 4; i++)
1689: ((u_long *)videoaddr)[gray_nextaddr++] = 0xaaaaaaaa;
1690: for (i = 0; i < 2 * videorowbytes / 4; i++)
1691: ((u_long *)videoaddr)[gray_nextaddr++] = 0x00000000;
1692: }
1693:
1694: __asm __volatile (" movl sp@+,d1;
1695: movl sp@+,d0;
1696: movl sp@+,a1;
1697: movl sp@+,a0");
1698: }
1699: #endif
1700:
1701: /* in locore */
1702: extern u_long ptest040(caddr_t addr, u_int fc);
1703: extern int get_pte(u_int addr, u_long pte[2], u_short * psr);
1704:
1705: /*
1706: * LAK (7/24/94): given a logical address, puts the physical address
1707: * in *phys and return 1, or returns 0 on failure. This is intended
1708: * to look through MacOS page tables.
1709: */
1710:
1711: u_long
1712: get_physical(u_int addr, u_long * phys)
1713: {
1714: extern u_int macos_tc;
1715: u_long pte[2], ph, mask;
1716: u_short psr;
1717: int i, numbits;
1718:
1719: if (mmutype == MMU_68040) {
1720: ph = ptest040((caddr_t)addr, FC_SUPERD);
1721: if ((ph & MMU40_RES) == 0) {
1722: ph = ptest040((caddr_t)addr, FC_USERD);
1723: if ((ph & MMU40_RES) == 0)
1724: return 0;
1725: }
1726: if ((ph & MMU40_TTR) != 0)
1727: ph = addr;
1728:
1729: mask = (macos_tc & 0x4000) ? 0x00001fff : 0x00000fff;
1730: ph &= (~mask);
1731: } else {
1732: i = get_pte(addr, pte, &psr);
1733:
1734: switch (i) {
1735: case -1:
1736: return 0;
1737: case 0:
1738: ph = pte[0] & 0xFFFFFF00;
1739: break;
1740: case 1:
1741: ph = pte[1] & 0xFFFFFF00;
1742: break;
1743: default:
1744: panic("get_physical(): bad get_pte()");
1745: }
1746:
1747: /*
1748: * We must now figure out how many levels down we went and
1749: * mask the bits appropriately -- the returned value may only
1750: * be the upper n bits, and we have to take the rest from addr.
1751: */
1752: numbits = 0;
1753: psr &= 0x0007; /* Number of levels we went */
1754: for (i = 0; i < psr; i++)
1755: numbits += (macos_tc >> (12 - i * 4)) & 0x0f;
1756:
1757: /*
1758: * We have to take the most significant "numbits" from
1759: * the returned value "ph", and the rest from our addr.
1760: * Assume that numbits != 0.
1761: */
1762: mask = (1 << (32 - numbits)) - 1;
1763: }
1764: *phys = ph + (addr & mask);
1765:
1766: return 1;
1767: }
1768:
1769: void check_video(char *, u_long, u_long);
1770:
1771: void
1772: check_video(id, limit, maxm)
1773: char *id;
1774: u_long limit, maxm;
1775: {
1776: u_long addr, phys;
1777:
1778: if (!get_physical(videoaddr, &phys)) {
1779: if (mac68k_machine.do_graybars)
1780: printf("get_mapping(): %s. False start.\n", id);
1781: } else {
1782: mac68k_vidlog = videoaddr;
1783: mac68k_vidphys = phys;
1784: mac68k_vidlen = 32768;
1785: addr = videoaddr + 32768;
1786: while (get_physical(addr, &phys)) {
1787: if ((phys - mac68k_vidphys) != mac68k_vidlen)
1788: break;
1789: if (mac68k_vidlen + 32768 > limit) {
1790: if (mac68k_machine.do_graybars) {
1791: printf("mapping: %s. Does it never end?\n",
1792: id);
1793: printf(" Forcing VRAM size ");
1794: printf("to a conservative %ldK.\n",
1795: maxm/1024);
1796: }
1797: mac68k_vidlen = maxm;
1798: break;
1799: }
1800: mac68k_vidlen += 32768;
1801: addr += 32768;
1802: }
1803: if (mac68k_machine.do_graybars) {
1804: printf(" %s internal video at paddr 0x%x, len 0x%x.\n",
1805: id, mac68k_vidphys, mac68k_vidlen);
1806: }
1807: }
1808: }
1809:
1810: /*
1811: * Find out how MacOS has mapped itself so we can do the same thing.
1812: * Returns the address of logical 0 so that locore can map the kernel
1813: * properly.
1814: */
1815: u_int
1816: get_mapping(void)
1817: {
1818: struct intvid_info_t *iip;
1819: u_long addr, lastpage, phys, len, limit;
1820: int i, last, same;
1821:
1822: numranges = 0;
1823: for (i = 0; i < 8; i++) {
1824: low[i] = 0;
1825: high[i] = 0;
1826: }
1827:
1828: lastpage = get_top_of_ram();
1829:
1830: get_physical(0, &load_addr);
1831:
1832: last = 0;
1833: for (addr = 0; addr <= lastpage && get_physical(addr, &phys);
1834: addr += PAGE_SIZE) {
1835: if (numranges > 0 && phys != high[last]) {
1836: /*
1837: * Attempt to find if this page is already
1838: * accounted for in an existing physical segment.
1839: */
1840: for (i = 0; i < numranges; i++) {
1841: if (low[i] <= phys && phys <= high[i]) {
1842: last = i;
1843: break;
1844: }
1845: }
1846: if (i >= numranges)
1847: last = numranges - 1;
1848:
1849: if (low[last] <= phys && phys < high[last])
1850: continue; /* Skip pages we've seen. */
1851: }
1852:
1853: if (numranges > 0 && phys == high[last]) {
1854: /* Common case: extend existing segment on high end */
1855: high[last] += PAGE_SIZE;
1856: } else {
1857: /* This is a new physical segment. */
1858: for (last = 0; last < numranges; last++)
1859: if (phys < low[last])
1860: break;
1861:
1862: /* Create space for segment, if necessary */
1863: if (last < numranges && phys < low[last]) {
1864: for (i = numranges; i > last; i--) {
1865: low[i] = low[i - 1];
1866: high[i] = high[i - 1];
1867: }
1868: }
1869:
1870: numranges++;
1871: low[last] = phys;
1872: high[last] = phys + PAGE_SIZE;
1873: }
1874:
1875: /* Coalesce adjoining segments as appropriate */
1876: if (last < (numranges - 1) && high[last] == low[last + 1] &&
1877: low[last + 1] != load_addr) {
1878: high[last] = high[last + 1];
1879: for (i = last + 1; i < numranges; i++) {
1880: low[i] = low[i + 1];
1881: high[i] = high[i + 1];
1882: }
1883: --numranges;
1884: }
1885: }
1886: if (mac68k_machine.do_graybars) {
1887: printf("System RAM: %ld bytes in %ld pages.\n",
1888: addr, addr / PAGE_SIZE);
1889: for (i = 0; i < numranges; i++) {
1890: printf(" Low = 0x%lx, high = 0x%lx\n",
1891: low[i], high[i]);
1892: }
1893: }
1894:
1895: /*
1896: * If we can't figure out the PA of the frame buffer by groveling
1897: * the page tables, assume that we already have the correct
1898: * address. This is the case on several of the PowerBook 1xx
1899: * series, in particular.
1900: */
1901: if (!get_physical(videoaddr, &phys))
1902: phys = videoaddr;
1903:
1904: /*
1905: * Find on-board video, if we have an idea of where to look
1906: * on this system.
1907: */
1908: for (iip = intvid_info; iip->machineid != 0; iip++)
1909: if (mac68k_machine.machineid == iip->machineid)
1910: break;
1911:
1912: if (mac68k_machine.machineid == iip->machineid &&
1913: (phys & ~iip->fbmask) >= iip->fbbase &&
1914: (phys & ~iip->fbmask) < (iip->fbbase + iip->fblen)) {
1915: mac68k_vidphys = phys & ~iip->fbmask;
1916: mac68k_vidlen = 32768 - (phys & 0x7fff);
1917:
1918: limit = iip->fbbase + iip->fblen - mac68k_vidphys;
1919: if (mac68k_vidlen > limit) {
1920: mac68k_vidlen = limit;
1921: } else {
1922: addr = videoaddr + mac68k_vidlen;
1923: while (get_physical(addr, &phys)) {
1924: if ((phys - mac68k_vidphys) != mac68k_vidlen)
1925: break;
1926: if (mac68k_vidlen + 32768 > limit) {
1927: mac68k_vidlen = limit;
1928: break;
1929: }
1930: mac68k_vidlen += 32768;
1931: addr += 32768;
1932: }
1933: }
1934: }
1935:
1936: if (mac68k_vidlen > 0) {
1937: /*
1938: * We've already figured out where internal video is.
1939: * Tell the user what we know.
1940: */
1941: if (mac68k_machine.do_graybars)
1942: printf("On-board video at addr 0x%lx (phys 0x%x), len 0x%x.\n",
1943: videoaddr, mac68k_vidphys, mac68k_vidlen);
1944: } else {
1945: /*
1946: * We should now look through all of NuBus space to find where
1947: * the internal video is being mapped. Just to be sure we
1948: * handle all the cases, we simply map our NuBus space exactly
1949: * how MacOS did it. As above, we find a bunch of ranges that
1950: * are contiguously mapped. Since there are a lot of pages
1951: * that are all mapped to 0, we handle that as a special case
1952: * where the length is negative. We search in increments of
1953: * 32768 because that's the page size that MacOS uses.
1954: */
1955: nbnumranges = 0;
1956: for (i = 0; i < NBMAXRANGES; i++) {
1957: nbphys[i] = 0;
1958: nblog[i] = 0;
1959: nblen[i] = 0;
1960: }
1961:
1962: same = 0;
1963: for (addr = NBBASE; addr < NBTOP; addr += 32768) {
1964: if (!get_physical(addr, &phys)) {
1965: continue;
1966: }
1967: len = nbnumranges == 0 ? 0 : nblen[nbnumranges - 1];
1968:
1969: #if DEBUG
1970: if (mac68k_machine.do_graybars)
1971: printf ("0x%lx --> 0x%lx\n", addr, phys);
1972: #endif
1973: if (nbnumranges > 0
1974: && addr == nblog[nbnumranges - 1] + len
1975: && phys == nbphys[nbnumranges - 1]) {
1976: /* Same as last one */
1977: nblen[nbnumranges - 1] += 32768;
1978: same = 1;
1979: } else {
1980: if ((nbnumranges > 0)
1981: && !same
1982: && (addr == nblog[nbnumranges - 1] + len)
1983: && (phys == nbphys[nbnumranges - 1] + len))
1984: nblen[nbnumranges - 1] += 32768;
1985: else {
1986: if (same) {
1987: nblen[nbnumranges - 1] = -len;
1988: same = 0;
1989: }
1990: if (nbnumranges == NBMAXRANGES) {
1991: if (mac68k_machine.do_graybars)
1992: printf("get_mapping(): "
1993: "Too many NuBus ranges.\n");
1994: break;
1995: }
1996: nbnumranges++;
1997: nblog[nbnumranges - 1] = addr;
1998: nbphys[nbnumranges - 1] = phys;
1999: nblen[nbnumranges - 1] = 32768;
2000: }
2001: }
2002: }
2003: if (same) {
2004: nblen[nbnumranges - 1] = -nblen[nbnumranges - 1];
2005: same = 0;
2006: }
2007: if (mac68k_machine.do_graybars) {
2008: printf("Non-system RAM (nubus, etc.):\n");
2009: for (i = 0; i < nbnumranges; i++) {
2010: printf(" Log = 0x%lx, Phys = 0x%lx, Len = 0x%lx (%lu)\n",
2011: nblog[i], nbphys[i], nblen[i], nblen[i]);
2012: }
2013: }
2014:
2015: /*
2016: * We must now find the logical address of internal video in the
2017: * ranges we made above. Internal video is at physical 0, but
2018: * a lot of pages map there. Instead, we look for the logical
2019: * page that maps to 32768 and go back one page.
2020: */
2021: for (i = 0; i < nbnumranges; i++) {
2022: if (nblen[i] > 0
2023: && nbphys[i] <= 32768
2024: && 32768 <= nbphys[i] + nblen[i]) {
2025: mac68k_vidlog = nblog[i] - nbphys[i];
2026: mac68k_vidlen = nblen[i] + nbphys[i];
2027: mac68k_vidphys = 0;
2028: break;
2029: }
2030: }
2031: if (i == nbnumranges) {
2032: if (0x60000000 <= videoaddr && videoaddr < 0x70000000) {
2033: if (mac68k_machine.do_graybars)
2034: printf("Checking for Internal Video ");
2035: /*
2036: * Kludge for IIvx internal video (60b0 0000).
2037: * PB 520 (6000 0000)
2038: */
2039: check_video("PB/IIvx (0x60?00000)",
2040: 1 * 1024 * 1024, 1 * 1024 * 1024);
2041: } else if (0x50F40000 <= videoaddr
2042: && videoaddr < 0x50FBFFFF) {
2043: /*
2044: * Kludge for LC internal video
2045: */
2046: check_video("LC video (0x50f40000)",
2047: 512 * 1024, 512 * 1024);
2048: } else if (0x50100100 <= videoaddr
2049: && videoaddr < 0x50400000) {
2050: /*
2051: * Kludge for AV internal video
2052: */
2053: check_video("AV video (0x50100100)",
2054: 1 * 1024 * 1024, 1 * 1024 * 1024);
2055: } else {
2056: if (mac68k_machine.do_graybars)
2057: printf( " no internal video at address 0 -- "
2058: "videoaddr is 0x%lx.\n", videoaddr);
2059: }
2060: } else {
2061: if (mac68k_machine.do_graybars) {
2062: printf(" Video address = 0x%lx\n", videoaddr);
2063: printf(" Int video starts at 0x%x\n",
2064: mac68k_vidlog);
2065: printf(" Length = 0x%x (%d) bytes\n",
2066: mac68k_vidlen, mac68k_vidlen);
2067: }
2068: }
2069: }
2070:
2071: return load_addr; /* Return physical address of logical 0 */
2072: }
2073:
2074: #ifdef DEBUG
2075: /*
2076: * Debugging code for locore page-traversal routine.
2077: */
2078: void printstar(void);
2079: void
2080: printstar(void)
2081: {
2082: /*
2083: * Be careful as we assume that no registers are clobbered
2084: * when we call this from assembly.
2085: */
2086: __asm __volatile (" movl a0,sp@-;
2087: movl a1,sp@-;
2088: movl d0,sp@-;
2089: movl d1,sp@-");
2090:
2091: /* printf("*"); */
2092:
2093: __asm __volatile (" movl sp@+,d1;
2094: movl sp@+,d0;
2095: movl sp@+,a1;
2096: movl sp@+,a0");
2097: }
2098: #endif
2099:
2100: /*
2101: * Console bell callback; modularizes the console terminal emulator
2102: * and the audio system, so neither requires direct knowledge of the
2103: * other.
2104: */
2105:
2106: void
2107: mac68k_set_bell_callback(callback, cookie)
2108: int (*callback)(void *, int, int, int);
2109: void *cookie;
2110: {
2111: mac68k_bell_callback = callback;
2112: mac68k_bell_cookie = (caddr_t)cookie;
2113: }
2114:
2115: int
2116: mac68k_ring_bell(freq, length, volume)
2117: int freq, length, volume;
2118: {
2119: if (mac68k_bell_callback)
2120: return ((*mac68k_bell_callback)(mac68k_bell_cookie,
2121: freq, length, volume));
2122: else
2123: return (ENXIO);
2124: }