Annotation of sys/arch/mvme68k/mvme68k/machdep.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: machdep.c,v 1.106 2007/06/06 17:15:12 deraadt Exp $ */
2:
3: /*
4: * Copyright (c) 1995 Theo de Raadt
5: * Copyright (c) 1999 Steve Murphree, Jr. (68060 support)
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: *
16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
17: * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
20: * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26: * SUCH DAMAGE.
27: *
28: * Copyright (c) 1988 University of Utah.
29: * Copyright (c) 1982, 1986, 1990, 1993
30: * The Regents of the University of California. All rights reserved.
31: *
32: * This code is derived from software contributed to Berkeley by
33: * the Systems Programming Group of the University of Utah Computer
34: * Science Department.
35: *
36: * Redistribution and use in source and binary forms, with or without
37: * modification, are permitted provided that the following conditions
38: * are met:
39: * 1. Redistributions of source code must retain the above copyright
40: * notice, this list of conditions and the following disclaimer.
41: * 2. Redistributions in binary form must reproduce the above copyright
42: * notice, this list of conditions and the following disclaimer in the
43: * documentation and/or other materials provided with the distribution.
44: * 3. Neither the name of the University nor the names of its contributors
45: * may be used to endorse or promote products derived from this software
46: * without specific prior written permission.
47: *
48: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58: * SUCH DAMAGE.
59: *
60: * from: Utah $Hdr: machdep.c 1.74 92/12/20$
61: *
62: * @(#)machdep.c 8.10 (Berkeley) 4/20/94
63: */
64:
65: #include <sys/param.h>
66: #include <sys/systm.h>
67: #include <sys/signalvar.h>
68: #include <sys/kernel.h>
69: #include <sys/proc.h>
70: #include <sys/buf.h>
71: #include <sys/reboot.h>
72: #include <sys/conf.h>
73: #include <sys/file.h>
74: #include <sys/timeout.h>
75: #include <sys/malloc.h>
76: #include <sys/mbuf.h>
77: #include <sys/msgbuf.h>
78: #include <sys/ioctl.h>
79: #include <sys/tty.h>
80: #include <sys/mount.h>
81: #include <sys/user.h>
82: #include <sys/exec.h>
83: #include <sys/core.h>
84: #include <sys/kcore.h>
85: #include <sys/vnode.h>
86: #include <sys/sysctl.h>
87: #include <sys/syscallargs.h>
88: #ifdef SYSVMSG
89: #include <sys/msg.h>
90: #endif
91: #include <sys/evcount.h>
92:
93: #include <machine/atomic.h>
94: #include <machine/autoconf.h>
95: #include <machine/cpu.h>
96: #include <machine/kcore.h>
97: #include <machine/prom.h>
98: #include <machine/psl.h>
99: #include <machine/pte.h>
100: #include <machine/reg.h>
101:
102: #ifdef MVME147
103: #include <mvme68k/dev/pccreg.h>
104: #endif
105:
106: #include <dev/cons.h>
107:
108: #include <net/netisr.h>
109:
110: #ifdef DDB
111: #include <machine/db_machdep.h>
112: #include <ddb/db_extern.h>
113: #include <ddb/db_interface.h>
114: #include <ddb/db_var.h>
115: #endif
116:
117: #include <uvm/uvm_extern.h>
118:
119: /* the following is used externally (sysctl_hw) */
120: char machine[] = MACHINE; /* cpu "architecture" */
121:
122: struct vm_map *exec_map = NULL;
123: struct vm_map *phys_map = NULL;
124:
125: extern vaddr_t avail_end;
126:
127: /*
128: * Declare these as initialized data so we can patch them.
129: */
130: #ifndef BUFCACHEPERCENT
131: #define BUFCACHEPERCENT 5
132: #endif
133:
134: #ifdef BUFPAGES
135: int bufpages = BUFPAGES;
136: #else
137: int bufpages = 0;
138: #endif
139: int bufcachepercent = BUFCACHEPERCENT;
140:
141: int physmem; /* size of physical memory, in pages */
142: /*
143: * safepri is a safe priority for sleep to set for a spin-wait
144: * during autoconfiguration or after a panic.
145: */
146: int safepri = PSL_LOWIPL;
147:
148: #ifdef COMPAT_SUNOS
149: extern struct emul emul_sunos;
150: #endif
151:
152: void dumpsys(void);
153: void initvectors(void);
154: void mvme68k_init(void);
155: void identifycpu(void);
156: int cpu_sysctl(int *, u_int, void *, size_t *, void *, size_t, struct proc *);
157: void dumpconf(void);
158: void straytrap(int, u_short);
159: void netintr(void *);
160: void myetheraddr(u_char *);
161: int fpu_gettype(void);
162: int memsize162(void);
163: int memsize1x7(void); /* in locore */
164: int memsize(void);
165: caddr_t allocsys(caddr_t);
166:
167: void
168: mvme68k_init()
169: {
170: extern vaddr_t avail_start;
171:
172: /*
173: * Tell the VM system about available physical memory. The
174: * mvme68k only has one segment.
175: */
176:
177: uvmexp.pagesize = NBPG;
178: uvm_setpagesize();
179: uvm_page_physload(atop(avail_start), atop(avail_end),
180: atop(avail_start), atop(avail_end), VM_FREELIST_DEFAULT);
181:
182: /*
183: * Put machine specific exception vectors in place.
184: */
185: initvectors();
186: }
187:
188: /*
189: * Console initialization: called early on from main,
190: * before vm init or startup, but already running virtual.
191: * Do enough configuration to choose and initialize a console.
192: */
193: void
194: consinit()
195: {
196: /*
197: * Initialize the console before we print anything out.
198: */
199: cninit();
200:
201: #ifdef DDB
202: db_machine_init();
203: ddb_init();
204:
205: if (boothowto & RB_KDB)
206: Debugger();
207: #endif
208: }
209:
210: /*
211: * cpu_startup: allocate memory for variable-sized tables,
212: * initialize cpu, and do autoconfiguration.
213: */
214: void
215: cpu_startup()
216: {
217: unsigned i;
218: caddr_t v;
219: vaddr_t minaddr, maxaddr;
220: vsize_t size;
221: #ifdef DEBUG
222: extern int pmapdebug;
223: int opmapdebug = pmapdebug;
224:
225: pmapdebug = 0;
226: #endif
227:
228: /*
229: * Initialize error message buffer (at end of core).
230: * avail_end was pre-decremented in pmap_bootstrap to compensate.
231: */
232: for (i = 0; i < btoc(MSGBUFSIZE); i++)
233: pmap_kenter_pa((vaddr_t)msgbufp + i * PAGE_SIZE,
234: avail_end + i * PAGE_SIZE, VM_PROT_READ|VM_PROT_WRITE);
235: pmap_update(pmap_kernel());
236: initmsgbuf((caddr_t)msgbufp, round_page(MSGBUFSIZE));
237:
238: /*
239: * Good {morning,afternoon,evening,night}.
240: */
241: printf("%s", version);
242: identifycpu();
243: printf("real mem = %u (%uMB)\n", ctob(physmem),
244: ctob(physmem) / 1024 / 1024);
245:
246: /*
247: * Find out how much space we need, allocate it,
248: * and then give everything true virtual addresses.
249: */
250: size = (vsize_t)allocsys((caddr_t)0);
251: if ((v = (caddr_t) uvm_km_zalloc(kernel_map, round_page(size))) == 0)
252: panic("startup: no room for tables");
253: if (allocsys(v) - v != size)
254: panic("startup: table size inconsistency");
255:
256: /*
257: * Determine how many buffers to allocate.
258: * We allocate bufcachepercent% of memory for buffer space.
259: */
260: if (bufpages == 0)
261: bufpages = physmem * bufcachepercent / 100;
262:
263: /* Restrict to at most 25% filled kvm */
264: if (bufpages >
265: (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) / PAGE_SIZE / 4)
266: bufpages = (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) /
267: PAGE_SIZE / 4;
268:
269: /*
270: * Allocate a submap for exec arguments. This map effectively
271: * limits the number of processes exec'ing at any time.
272: */
273: minaddr = vm_map_min(kernel_map);
274: exec_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
275: 16*NCARGS, VM_MAP_PAGEABLE, FALSE, NULL);
276:
277: /*
278: * Allocate a submap for physio.
279: */
280: phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
281: VM_PHYS_SIZE, 0, FALSE, NULL);
282:
283: #ifdef DEBUG
284: pmapdebug = opmapdebug;
285: #endif
286:
287: /*
288: * Set up buffers, so they can be used to read disk labels.
289: */
290: bufinit();
291:
292: printf("avail mem = %u (%uMB)\n",
293: ptoa(uvmexp.free), ptoa(uvmexp.free) / 1024 / 1024);
294:
295: /*
296: * Configure the system.
297: */
298: if (boothowto & RB_CONFIG) {
299: #ifdef BOOT_CONFIG
300: user_config();
301: #else
302: printf("kernel does not support -c; continuing..\n");
303: #endif
304: }
305: }
306:
307: /*
308: * Allocate space for system data structures. We are given
309: * a starting virtual address and we return a final virtual
310: * address; along the way we set each data structure pointer.
311: *
312: * You call allocsys() with 0 to find out how much space we want,
313: * allocate that much and fill it with zeroes, and then call
314: * allocsys() again with the correct base virtual address.
315: */
316: caddr_t
317: allocsys(caddr_t v)
318: {
319:
320: #define valloc(name, type, num) \
321: (name) = (type *)v; v = (caddr_t)((name) + (num))
322: #ifdef SYSVMSG
323: valloc(msgpool, char, msginfo.msgmax);
324: valloc(msgmaps, struct msgmap, msginfo.msgseg);
325: valloc(msghdrs, struct msg, msginfo.msgtql);
326: valloc(msqids, struct msqid_ds, msginfo.msgmni);
327: #endif
328:
329: return (v);
330: }
331:
332: /*
333: * Info for CTL_HW
334: */
335: char cpu_model[120];
336:
337: int cputyp;
338: int cpuspeed;
339:
340: struct mvmeprom_brdid brdid;
341:
342: void
343: identifycpu()
344: {
345: char mc;
346: char speed[6];
347: char suffix[30];
348: int len;
349:
350: bzero(suffix, sizeof suffix);
351:
352: switch (mmutype) {
353: case MMU_68060:
354: mc = '6';
355: break;
356: case MMU_68040:
357: mc = '4';
358: break;
359: case MMU_68030:
360: mc = '3';
361: break;
362: default:
363: mc = '2';
364: }
365:
366: switch (cputyp) {
367: #ifdef MVME147
368: case CPU_147:
369: snprintf(suffix, sizeof suffix, "MVME%x", brdid.model);
370: cpuspeed = pccspeed((struct pccreg *)IIOV(0xfffe1000));
371: snprintf(speed, sizeof speed, "%02d", cpuspeed);
372: break;
373: #endif
374: #if defined(MVME162) || defined(MVME167) || defined(MVME172) || defined(MVME177)
375: case CPU_162:
376: case CPU_167:
377: case CPU_172:
378: case CPU_177:
379: bzero(speed, sizeof speed);
380: speed[0] = brdid.speed[0];
381: speed[1] = brdid.speed[1];
382: if (brdid.speed[2] != '0' &&
383: brdid.speed[3] != '0') {
384: speed[2] = '.';
385: speed[3] = brdid.speed[2];
386: speed[4] = brdid.speed[3];
387: }
388: cpuspeed = (speed[0] - '0') * 10 + (speed[1] - '0');
389: bcopy(brdid.longname, suffix, sizeof(brdid.longname));
390: for (len = strlen(suffix)-1; len; len--) {
391: if (suffix[len] == ' ')
392: suffix[len] = '\0';
393: else
394: break;
395: }
396: break;
397: #endif
398: }
399: snprintf(cpu_model, sizeof cpu_model,
400: "Motorola %s: %sMHz MC680%c0 CPU", suffix, speed, mc);
401: switch (mmutype) {
402: #if defined(M68040)
403: case MMU_68040:
404: /* FALLTHROUGH */
405: #endif
406: #if defined(M68060)
407: case MMU_68060:
408: /* FALLTHROUGH */
409: #endif
410: case MMU_68030:
411: strlcat(cpu_model, "+MMU", sizeof cpu_model);
412: break;
413: case MMU_68851:
414: strlcat(cpu_model, ", MC68851 MMU", sizeof cpu_model);
415: break;
416: default:
417: printf("%s\n", cpu_model);
418: panic("unknown MMU type %d", mmutype);
419: }
420:
421: switch (mmutype) {
422: #if defined(M68060)
423: case MMU_68060:
424: strlcat(cpu_model,"+FPU, 8k on-chip physical I/D caches",
425: sizeof cpu_model);
426: break;
427: #endif
428: #if defined(M68040)
429: case MMU_68040:
430: strlcat(cpu_model, "+FPU, 4k on-chip physical I/D caches",
431: sizeof cpu_model);
432: break;
433: #endif
434: #if defined(M68030) || defined(M68020)
435: default:
436: fputype = fpu_gettype();
437:
438: switch (fputype) {
439: case FPU_NONE:
440: break;
441: case FPU_68881:
442: case FPU_68882:
443: len = strlen (cpu_model);
444: snprintf(cpu_model + len, sizeof cpu_model - len,
445: ", MC6888%d FPU", fputype);
446: break;
447: default:
448: strlcat(cpu_model, ", unknown FPU", sizeof cpu_model);
449: break;
450: }
451: break;
452: #endif
453: }
454: printf("%s\n", cpu_model);
455: }
456:
457: /*
458: * machine dependent system variables.
459: */
460: int
461: cpu_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
462: int *name;
463: u_int namelen;
464: void *oldp;
465: size_t *oldlenp;
466: void *newp;
467: size_t newlen;
468: struct proc *p;
469: {
470: dev_t consdev;
471:
472: /* all sysctl names at this level are terminal */
473: if (namelen != 1)
474: return (ENOTDIR); /* overloaded */
475:
476: switch (name[0]) {
477: case CPU_CONSDEV:
478: if (cn_tab != NULL)
479: consdev = cn_tab->cn_dev;
480: else
481: consdev = NODEV;
482: return (sysctl_rdstruct(oldp, oldlenp, newp, &consdev,
483: sizeof consdev));
484: default:
485: return (EOPNOTSUPP);
486: }
487: /* NOTREACHED */
488: }
489:
490: int waittime = -1;
491:
492: __dead void
493: boot(howto)
494: int howto;
495: {
496: /* If system is cold, just halt. */
497: if (cold) {
498: /* (Unless the user explicitly asked for reboot.) */
499: if ((howto & RB_USERREQ) == 0)
500: howto |= RB_HALT;
501: goto haltsys;
502: }
503:
504: /* take a snap shot before clobbering any registers */
505: if (curproc && curproc->p_addr)
506: savectx(&curproc->p_addr->u_pcb);
507:
508: boothowto = howto;
509: if ((howto & RB_NOSYNC) == 0 && waittime < 0) {
510: extern struct proc proc0;
511: /* do that another panic fly away */
512: if (curproc == NULL)
513: curproc = &proc0;
514: waittime = 0;
515: vfs_shutdown();
516: /*
517: * If we've been adjusting the clock, the todr
518: * will be out of synch; adjust it now unless
519: * the system was sitting in ddb.
520: */
521: if ((howto & RB_TIMEBAD) == 0) {
522: resettodr();
523: } else {
524: printf("WARNING: not updating battery clock\n");
525: }
526: }
527:
528: /* Disable interrupts. */
529: splhigh();
530:
531: /* If rebooting and a dump is requested, do it. */
532: if (howto & RB_DUMP)
533: dumpsys();
534:
535: haltsys:
536: /* Run any shutdown hooks. */
537: doshutdownhooks();
538:
539: if (howto & RB_HALT) {
540: printf("System halted. Press any key to reboot...\n\n");
541: cngetc();
542: }
543:
544: doboot();
545:
546: for (;;);
547: /*NOTREACHED*/
548: }
549:
550: /*
551: * These variables are needed by /sbin/savecore
552: */
553: u_long dumpmag = 0x8fca0101; /* magic number */
554: int dumpsize = 0; /* pages */
555: long dumplo = 0; /* blocks */
556: cpu_kcore_hdr_t cpu_kcore_hdr;
557:
558: /*
559: * This is called by configure to set dumplo and dumpsize.
560: * Dumps always skip the first PAGE_SIZE of disk space
561: * in case there might be a disk label stored there.
562: * If there is extra space, put dump at the end to
563: * reduce the chance that swapping trashes it.
564: */
565: void
566: dumpconf(void)
567: {
568: int nblks; /* size of dump area */
569:
570: if (dumpdev == NODEV ||
571: (nblks = (bdevsw[major(dumpdev)].d_psize)(dumpdev)) == 0)
572: return;
573: if (nblks <= ctod(1))
574: return;
575:
576: dumpsize = physmem;
577:
578: /* mvme68k only uses a single segment. */
579: cpu_kcore_hdr.ram_segs[0].start = 0;
580: cpu_kcore_hdr.ram_segs[0].size = ctob(physmem);
581: cpu_kcore_hdr.mmutype = mmutype;
582: cpu_kcore_hdr.kernel_pa = 0;
583: cpu_kcore_hdr.sysseg_pa = pmap_kernel()->pm_stpa;
584:
585: /* Always skip the first block, in case there is a label there. */
586: if (dumplo < ctod(1))
587: dumplo = ctod(1);
588:
589: /* Put dump at end of partition, and make it fit. */
590: if (dumpsize + 1 > dtoc(nblks - dumplo))
591: dumpsize = dtoc(nblks - dumplo) - 1;
592: if (dumplo < nblks - ctod(dumpsize) - 1)
593: dumplo = nblks - ctod(dumpsize) - 1;
594: }
595:
596: /*
597: * Doadump comes here after turning off memory management and
598: * getting on the dump stack, either when called above, or by
599: * the auto-restart code.
600: */
601: void
602: dumpsys()
603: {
604: int maj;
605: int psize;
606: daddr64_t blkno; /* current block to write */
607: /* dump routine */
608: int (*dump)(dev_t, daddr64_t, caddr_t, size_t);
609: int pg; /* page being dumped */
610: paddr_t maddr; /* PA being dumped */
611: int error; /* error code from (*dump)() */
612: kcore_seg_t *kseg_p;
613: cpu_kcore_hdr_t *chdr_p;
614: char dump_hdr[dbtob(1)]; /* XXX assume hdr fits in 1 block */
615:
616: extern int msgbufmapped;
617:
618: msgbufmapped = 0;
619:
620: /* Make sure dump device is valid. */
621: if (dumpdev == NODEV)
622: return;
623: if (dumpsize == 0) {
624: dumpconf();
625: if (dumpsize == 0)
626: return;
627: }
628: maj = major(dumpdev);
629: if (dumplo < 0) {
630: printf("\ndump to dev %u,%u not possible\n", maj,
631: minor(dumpdev));
632: return;
633: }
634: dump = bdevsw[maj].d_dump;
635: blkno = dumplo;
636:
637: printf("\ndumping to dev %u,%u offset %ld\n", maj,
638: minor(dumpdev), dumplo);
639:
640: kseg_p = (kcore_seg_t *)dump_hdr;
641: chdr_p = (cpu_kcore_hdr_t *)&dump_hdr[ALIGN(sizeof(*kseg_p))];
642: bzero(dump_hdr, sizeof(dump_hdr));
643:
644: /*
645: * Generate a segment header
646: */
647: CORE_SETMAGIC(*kseg_p, KCORE_MAGIC, MID_MACHINE, CORE_CPU);
648: kseg_p->c_size = dbtob(1) - ALIGN(sizeof(*kseg_p));
649:
650: /*
651: * Add the md header
652: */
653: *chdr_p = cpu_kcore_hdr;
654:
655: printf("dump ");
656: psize = (*bdevsw[maj].d_psize)(dumpdev);
657: if (psize == -1) {
658: printf("area unavailable\n");
659: return;
660: }
661:
662: /* Dump the header. */
663: error = (*dump) (dumpdev, blkno++, (caddr_t)dump_hdr, dbtob(1));
664: if (error != 0)
665: goto abort;
666:
667: maddr = (paddr_t)0;
668: for (pg = 0; pg < dumpsize; pg++) {
669: #define NPGMB (1024 * 1024 / PAGE_SIZE)
670: /* print out how many MBs we have dumped */
671: if (pg != 0 && (pg % NPGMB) == 0)
672: printf("%d ", pg / NPGMB);
673: #undef NPGMB
674: pmap_kenter_pa((vaddr_t)vmmap, maddr, VM_PROT_READ);
675: pmap_update(pmap_kernel());
676: error = (*dump)(dumpdev, blkno, vmmap, PAGE_SIZE);
677: pmap_kremove((vaddr_t)vmmap, PAGE_SIZE);
678: pmap_update(pmap_kernel());
679:
680: if (error == 0) {
681: maddr += PAGE_SIZE;
682: blkno += btodb(PAGE_SIZE);
683: } else
684: break;
685: }
686: abort:
687: switch (error) {
688: case 0:
689: printf("succeeded\n");
690: break;
691:
692: case ENXIO:
693: printf("device bad\n");
694: break;
695:
696: case EFAULT:
697: printf("device not ready\n");
698: break;
699:
700: case EINVAL:
701: printf("area improper\n");
702: break;
703:
704: case EIO:
705: printf("i/o error\n");
706: break;
707:
708: case EINTR:
709: printf("aborted from console\n");
710: break;
711:
712: default:
713: printf("error %d\n", error);
714: break;
715: }
716: }
717:
718: #if defined(M68060)
719: int m68060_pcr_init = 0x20 | PCR_SUPERSCALAR; /* make this patchable */
720: #endif
721:
722: void
723: initvectors()
724: {
725: typedef void trapfun(void);
726: extern trapfun *vectab[256];
727: #if defined(M68060)
728: #if defined(M060SP)
729: extern trapfun intemu60, fpiemu60, fpdemu60, fpeaemu60;
730: extern u_int8_t FP_CALL_TOP[];
731: #else
732: extern trapfun illinst;
733: #endif
734: extern trapfun fpfault;
735: #endif
736: #if defined(M68040) && defined(FPSP)
737: extern u_long fpvect_tab, fpvect_end, fpsp_tab;
738: #endif
739:
740: switch (cputype) {
741: #ifdef M68060
742: case CPU_68060:
743: asm volatile ("movl %0,d0; .word 0x4e7b,0x0808" : :
744: "d"(m68060_pcr_init):"d0" );
745:
746: #if defined(M060SP)
747: /* integer support */
748: vectab[61] = intemu60/*(trapfun *)&I_CALL_TOP[128 + 0x00]*/;
749:
750: /* floating point support */
751: /*
752: * XXX maybe we really should run-time check for the
753: * stack frame format here:
754: */
755: vectab[11] = fpiemu60/*(trapfun *)&FP_CALL_TOP[128 + 0x30]*/;
756:
757: vectab[55] = fpdemu60/*(trapfun *)&FP_CALL_TOP[128 + 0x38]*/;
758: vectab[60] = fpeaemu60/*(trapfun *)&FP_CALL_TOP[128 + 0x40]*/;
759:
760: vectab[54] = (trapfun *)&FP_CALL_TOP[128 + 0x00];
761: vectab[52] = (trapfun *)&FP_CALL_TOP[128 + 0x08];
762: vectab[53] = (trapfun *)&FP_CALL_TOP[128 + 0x10];
763: vectab[51] = (trapfun *)&FP_CALL_TOP[128 + 0x18];
764: vectab[50] = (trapfun *)&FP_CALL_TOP[128 + 0x20];
765: vectab[49] = (trapfun *)&FP_CALL_TOP[128 + 0x28];
766: #else
767: vectab[61] = illinst;
768: #endif
769: vectab[48] = fpfault;
770: break;
771: #endif
772: #if defined(M68040) && defined(FPSP)
773: case CPU_68040:
774: bcopy(&fpsp_tab, &fpvect_tab,
775: (&fpvect_end - &fpvect_tab) * sizeof (fpvect_tab));
776: break;
777: #endif
778: default:
779: break;
780: }
781: }
782:
783: void
784: straytrap(pc, evec)
785: int pc;
786: u_short evec;
787: {
788: printf("unexpected trap (vector 0x%x) from %x\n",
789: (evec & 0xFFF) >> 2, pc);
790: }
791:
792: int *nofault;
793:
794: int
795: badpaddr(addr, size)
796: paddr_t addr;
797: int size;
798: {
799: int off = (int)addr & PGOFSET;
800: vaddr_t v;
801: paddr_t p = trunc_page(addr);
802: int x;
803:
804: v = mapiodev(p, NBPG);
805: if (v == 0)
806: return (1);
807: x = badvaddr(v + off, size);
808: unmapiodev(v, NBPG);
809: return (x);
810: }
811:
812: int
813: badvaddr(addr, size)
814: vaddr_t addr;
815: int size;
816: {
817: int i;
818: label_t faultbuf;
819:
820: nofault = (int *) &faultbuf;
821: if (setjmp((label_t *)nofault)) {
822: nofault = (int *)0;
823: return (1);
824: }
825: switch (size) {
826: case 1:
827: i = *(volatile char *)addr;
828: break;
829: case 2:
830: i = *(volatile short *)addr;
831: break;
832: case 4:
833: i = *(volatile long *)addr;
834: break;
835: }
836: nofault = (int *)0;
837: return (0);
838: }
839:
840: int netisr;
841:
842: void
843: netintr(arg)
844: void *arg;
845: {
846: int n;
847:
848: while ((n = netisr) != 0) {
849: atomic_clearbits_int(&netisr, n);
850:
851: #define DONETISR(bit, fn) \
852: do { \
853: if (n & (1 << (bit))) \
854: (fn)(); \
855: } while (0)
856:
857: #include <net/netisr_dispatch.h>
858:
859: #undef DONETISR
860: }
861: }
862:
863: /*
864: * Level 7 interrupts are normally caused by the ABORT switch,
865: * drop into ddb.
866: */
867: void
868: nmihand(frame)
869: void *frame;
870: {
871: #ifdef DDB
872: printf("NMI ... going to debugger\n");
873: Debugger();
874: #else
875: /* panic?? */
876: printf("unexpected level 7 interrupt ignored\n");
877: #endif
878: }
879:
880: /*
881: * cpu_exec_aout_makecmds():
882: * cpu-dependent a.out format hook for execve().
883: *
884: * Determine of the given exec package refers to something which we
885: * understand and, if so, set up the vmcmds for it.
886: */
887: int
888: cpu_exec_aout_makecmds(p, epp)
889: struct proc *p;
890: struct exec_package *epp;
891: {
892: int error = ENOEXEC;
893:
894: #ifdef COMPAT_SUNOS
895: {
896: extern int sunos_exec_aout_makecmds(struct proc *, struct exec_package *);
897: if ((error = sunos_exec_aout_makecmds(p, epp)) == 0)
898: return (0);
899: }
900: #endif
901: return (error);
902: }
903:
904: u_char myea[6] = { 0x08, 0x00, 0x3e, 0xff, 0xff, 0xff};
905:
906: void
907: myetheraddr(ether)
908: u_char *ether;
909: {
910: bcopy(myea, ether, sizeof myea);
911: }
912:
913: #if defined(M68030) || defined(M68020)
914: int
915: fpu_gettype()
916: {
917: /*
918: * A 68881 idle frame is 28 bytes and a 68882's is 60 bytes.
919: * We, of course, need to have enough room for either.
920: */
921: int fpframe[60 / sizeof(int)];
922: label_t faultbuf;
923: u_char b;
924:
925: nofault = (int *) &faultbuf;
926: if (setjmp((label_t *)nofault)) {
927: nofault = (int *)0;
928: return (0); /* no FPU */
929: }
930:
931: /*
932: * Synchronize FPU or cause a fault.
933: * This should leave the 881/882 in the IDLE state,
934: * state, so we can determine which we have by
935: * examining the size of the FP state frame
936: */
937: asm("fnop");
938:
939: nofault = (int *)0;
940:
941: /*
942: * Presumably, this will not cause a fault--the fnop should
943: * have if this will. We save the state in order to get the
944: * size of the frame.
945: */
946: asm("movl %0, a0; fsave a0@" : : "a" (fpframe) : "a0" );
947: b = *((u_char *) fpframe + 1);
948:
949: /*
950: * Now, restore a NULL state to reset the FPU.
951: */
952: fpframe[0] = fpframe[1] = 0;
953: m68881_restore((struct fpframe *)fpframe);
954:
955: if (b == 0x18)
956: return (FPU_68881); /* The size of a 68881 IDLE frame is 0x18 */
957: if (b == 0x38)
958: return (FPU_68882); /* 68882 frame is 0x38 bytes long */
959: return (FPU_UNKNOWN); /* unknown FPU type */
960: }
961: #endif
962:
963:
964: #if defined(MVME162) || defined(MVME172)
965: #include <mvme68k/dev/mcreg.h>
966: /*
967: * XXX
968: * used by locore.s to figure out how much memory is on the machine.
969: * At this stage we only know that our machine is a 162. It is very
970: * unfortunate that the MCchip's address must be encoded here.
971: */
972: int
973: memsize162()
974: {
975: struct mcreg *mc = (struct mcreg *)0xfff42000;
976:
977: switch (mc->mc_memoptions & MC_MEMOPTIONS_DRAMMASK) {
978: case MC_MEMOPTIONS_DRAM1M:
979: return (1*1024*1024);
980: case MC_MEMOPTIONS_DRAM2M:
981: return (2*1024*1024);
982: case MC_MEMOPTIONS_DRAM4M:
983: return (4*1024*1024);
984: case MC_MEMOPTIONS_DRAM4M2:
985: return (4*1024*1024);
986: case MC_MEMOPTIONS_DRAM8M:
987: return (8*1024*1024);
988: case MC_MEMOPTIONS_DRAM16M:
989: return (16*1024*1024);
990: default:
991: /*
992: * XXX if the machine has no MC-controlled memory,
993: * perhaps it has a MCECC or MEMC040 controller?
994: */
995: return (memsize1x7());
996: }
997: }
998: #endif
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 / mvme68k / mvme68k