Annotation of sys/arch/luna88k/luna88k/machdep.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: machdep.c,v 1.44 2007/06/06 17:15:12 deraadt Exp $ */
2: /*
3: * Copyright (c) 1998, 1999, 2000, 2001 Steve Murphree, Jr.
4: * Copyright (c) 1996 Nivas Madhur
5: * All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: * 3. All advertising materials mentioning features or use of this software
16: * must display the following acknowledgement:
17: * This product includes software developed by Nivas Madhur.
18: * 4. The name of the author may not be used to endorse or promote products
19: * derived from this software without specific prior written permission
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31: *
32: */
33: /*
34: * Mach Operating System
35: * Copyright (c) 1993-1991 Carnegie Mellon University
36: * Copyright (c) 1991 OMRON Corporation
37: * All Rights Reserved.
38: *
39: * Permission to use, copy, modify and distribute this software and its
40: * documentation is hereby granted, provided that both the copyright
41: * notice and this permission notice appear in all copies of the
42: * software, derivative works or modified versions, and any portions
43: * thereof, and that both notices appear in supporting documentation.
44: *
45: * CARNEGIE MELLON AND OMRON ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS IS"
46: * CONDITION. CARNEGIE MELLON AND OMRON DISCLAIM ANY LIABILITY OF ANY KIND
47: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
48: *
49: * Carnegie Mellon requests users of this software to return to
50: *
51: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
52: * School of Computer Science
53: * Carnegie Mellon University
54: * Pittsburgh PA 15213-3890
55: *
56: * any improvements or extensions that they make and grant Carnegie the
57: * rights to redistribute these changes.
58: */
59:
60: #include <sys/param.h>
61: #include <sys/systm.h>
62: #include <sys/kernel.h>
63: #include <sys/proc.h>
64: #include <sys/user.h>
65: #include <sys/buf.h>
66: #include <sys/reboot.h>
67: #include <sys/conf.h>
68: #include <sys/malloc.h>
69: #include <sys/mount.h>
70: #include <sys/msgbuf.h>
71: #include <sys/syscallargs.h>
72: #ifdef SYSVMSG
73: #include <sys/msg.h>
74: #endif
75: #include <sys/exec.h>
76: #include <sys/sysctl.h>
77: #include <sys/errno.h>
78: #include <sys/extent.h>
79: #include <sys/core.h>
80: #include <sys/kcore.h>
81:
82: #include <machine/asm.h>
83: #include <machine/asm_macro.h>
84: #include <machine/board.h>
85: #include <machine/cmmu.h>
86: #include <machine/cpu.h>
87: #include <machine/kcore.h>
88: #include <machine/reg.h>
89: #include <machine/trap.h>
90: #include <machine/m88100.h>
91:
92: #include <luna88k/luna88k/isr.h>
93:
94: #include <dev/cons.h>
95:
96: #include <uvm/uvm_extern.h>
97:
98: #include "ksyms.h"
99: #if DDB
100: #include <machine/db_machdep.h>
101: #include <ddb/db_extern.h>
102: #include <ddb/db_interface.h>
103: #include <ddb/db_output.h> /* db_printf() */
104: #endif /* DDB */
105:
106: caddr_t allocsys(caddr_t);
107: void consinit(void);
108: void dumpconf(void);
109: void dumpsys(void);
110: int getcpuspeed(void);
111: u_int getipl(void);
112: void identifycpu(void);
113: void luna88k_bootstrap(void);
114: void savectx(struct pcb *);
115: void secondary_main(void);
116: void secondary_pre_main(void);
117: void setlevel(unsigned int);
118:
119: vaddr_t size_memory(void);
120: void powerdown(void);
121: void get_fuse_rom_data(void);
122: void get_nvram_data(void);
123: char *nvram_by_symbol(char *);
124: void get_autoboot_device(void); /* in disksubr.c */
125: int clockintr(void *); /* in clock.c */
126:
127: /*
128: * *int_mask_reg[CPU]
129: * Points to the hardware interrupt status register for each CPU.
130: */
131: unsigned int *volatile int_mask_reg[] = {
132: (unsigned int *)INT_ST_MASK0,
133: (unsigned int *)INT_ST_MASK1,
134: (unsigned int *)INT_ST_MASK2,
135: (unsigned int *)INT_ST_MASK3
136: };
137:
138: unsigned int luna88k_curspl[] = {0, 0, 0, 0};
139:
140: unsigned int int_set_val[INT_LEVEL] = {
141: INT_SET_LV0,
142: INT_SET_LV1,
143: INT_SET_LV2,
144: INT_SET_LV3,
145: INT_SET_LV4,
146: INT_SET_LV5,
147: INT_SET_LV6,
148: INT_SET_LV7
149: };
150:
151: /*
152: * *clock_reg[CPU]
153: */
154: unsigned int *volatile clock_reg[] = {
155: (unsigned int *)OBIO_CLOCK0,
156: (unsigned int *)OBIO_CLOCK1,
157: (unsigned int *)OBIO_CLOCK2,
158: (unsigned int *)OBIO_CLOCK3
159: };
160:
161: /*
162: * FUSE ROM and NVRAM data
163: */
164: struct fuse_rom_byte {
165: u_int32_t h;
166: u_int32_t l;
167: };
168: #define FUSE_ROM_BYTES (FUSE_ROM_SPACE / sizeof(struct fuse_rom_byte))
169: char fuse_rom_data[FUSE_ROM_BYTES];
170:
171: #define NNVSYM 8
172: #define NVSYMLEN 16
173: #define NVVALLEN 16
174: struct nvram_t {
175: char symbol[NVSYMLEN];
176: char value[NVVALLEN];
177: } nvram[NNVSYM];
178:
179: vaddr_t obiova;
180:
181: int physmem; /* available physical memory, in pages */
182:
183: struct vm_map *exec_map = NULL;
184: struct vm_map *phys_map = NULL;
185:
186: /*
187: * Declare these as initialized data so we can patch them.
188: */
189: #ifndef BUFCACHEPERCENT
190: #define BUFCACHEPERCENT 5
191: #endif
192:
193: #ifdef BUFPAGES
194: int bufpages = BUFPAGES;
195: #else
196: int bufpages = 0;
197: #endif
198: int bufcachepercent = BUFCACHEPERCENT;
199:
200: /*
201: * Info for CTL_HW
202: */
203: char machine[] = MACHINE; /* cpu "architecture" */
204: char cpu_model[120];
205:
206: #if defined(DDB) || NKSYMS > 0
207: extern char *esym;
208: #endif
209:
210: int machtype = LUNA_88K; /* may be overwritten in cpu_startup() */
211: int cputyp = CPU_88100; /* XXX: aoyama */
212: int boothowto; /* XXX: should be set in boot loader and locore.S */
213: int bootdev; /* XXX: should be set in boot loader and locore.S */
214: int cpuspeed = 33; /* safe guess */
215: int sysconsole = 1; /* 0 = ttya, 1 = keyboard/mouse, used in dev/sio.c */
216: u_int16_t dipswitch = 0; /* set in locore.S */
217: int hwplanebits; /* set in locore.S */
218:
219: extern struct consdev syscons; /* in dev/siotty.c */
220:
221: extern void syscnattach(int); /* in dev/siotty.c */
222: extern int omfb_cnattach(void); /* in dev/lunafb.c */
223: extern void ws_cnattach(void); /* in dev/lunaws.c */
224:
225: vaddr_t first_addr;
226: vaddr_t last_addr;
227:
228: vaddr_t avail_start, avail_end;
229: vaddr_t virtual_avail, virtual_end;
230:
231: extern struct user *proc0paddr;
232:
233: /*
234: * This is to fake out the console routines, while booting.
235: * We could use directly the romtty console, but we want to be able to
236: * configure a kernel without romtty since we do not necessarily need a
237: * full-blown console driver.
238: */
239: cons_decl(romtty);
240: extern void nullcnpollc(dev_t, int);
241:
242: struct consdev romttycons = {
243: NULL,
244: NULL,
245: romttycngetc,
246: romttycnputc,
247: nullcnpollc,
248: NULL,
249: makedev(14, 0),
250: CN_NORMAL,
251: };
252:
253: /*
254: * Early console initialization: called early on from main, before vm init.
255: */
256: void
257: consinit()
258: {
259: /*
260: * Initialize the console before we print anything out.
261: */
262: if (sysconsole == 0) {
263: syscnattach(0);
264: } else {
265: omfb_cnattach();
266: ws_cnattach();
267: }
268:
269: #if defined(DDB)
270: db_machine_init();
271: ddb_init();
272: if (boothowto & RB_KDB)
273: Debugger();
274: #endif
275: }
276:
277: /*
278: * Figure out how much real memory is available.
279: * Start looking from the megabyte after the end of the kernel data,
280: * until we find non-memory.
281: */
282: vaddr_t
283: size_memory()
284: {
285: unsigned int *volatile look;
286: unsigned int *max;
287: #if 0
288: extern char *end;
289: #endif
290: #define PATTERN 0x5a5a5a5a
291: #define STRIDE (4*1024) /* 4k at a time */
292: #define Roundup(value, stride) (((unsigned)(value) + (stride) - 1) & ~((stride)-1))
293: /*
294: * count it up.
295: */
296: max = (void *)MAXPHYSMEM;
297: #if 0
298: for (look = (void *)Roundup(end, STRIDE); look < max;
299: #else
300: for (look = (void *)first_addr; look < max;
301: #endif
302: look = (int *)((unsigned)look + STRIDE)) {
303: unsigned save;
304:
305: /* if can't access, we've reached the end */
306: if (badaddr((vaddr_t)look, 4)) {
307: #if defined(DEBUG)
308: printf("%x\n", look);
309: #endif
310: look = (int *)((int)look - STRIDE);
311: break;
312: }
313:
314: /*
315: * If we write a value, we expect to read the same value back.
316: * We'll do this twice, the 2nd time with the opposite bit
317: * pattern from the first, to make sure we check all bits.
318: */
319: save = *look;
320: if (*look = PATTERN, *look != PATTERN)
321: break;
322: if (*look = ~PATTERN, *look != ~PATTERN)
323: break;
324: *look = save;
325: }
326:
327: return (trunc_page((unsigned)look));
328: }
329:
330: int
331: getcpuspeed()
332: {
333: switch(machtype) {
334: case LUNA_88K:
335: return 25;
336: case LUNA_88K2:
337: return 33;
338: default:
339: panic("getcpuspeed: can not determine CPU speed");
340: }
341: }
342:
343: void
344: identifycpu()
345: {
346: cpuspeed = getcpuspeed();
347: snprintf(cpu_model, sizeof cpu_model,
348: "OMRON LUNA-88K%s, %dMHz",
349: machtype == LUNA_88K2 ? "2" : "", cpuspeed);
350: }
351:
352: void
353: cpu_startup()
354: {
355: caddr_t v;
356: int sz, i;
357: vaddr_t minaddr, maxaddr;
358:
359: /*
360: * Initialize error message buffer (at end of core).
361: * avail_end was pre-decremented in luna88k_bootstrap() to compensate.
362: */
363: for (i = 0; i < btoc(MSGBUFSIZE); i++)
364: pmap_kenter_pa((paddr_t)msgbufp + i * PAGE_SIZE,
365: avail_end + i * PAGE_SIZE, VM_PROT_READ | VM_PROT_WRITE);
366: pmap_update(pmap_kernel());
367: initmsgbuf((caddr_t)msgbufp, round_page(MSGBUFSIZE));
368:
369: /* Determine the machine type from FUSE ROM data. */
370: get_fuse_rom_data();
371: if (strncmp(fuse_rom_data, "MNAME=LUNA88K+", 14) == 0) {
372: machtype = LUNA_88K2;
373: }
374:
375: /* Determine the 'auto-boot' device from NVRAM data */
376: get_nvram_data();
377: get_autoboot_device();
378:
379: /*
380: * Good {morning,afternoon,evening,night}.
381: */
382: printf(version);
383: identifycpu();
384: printf("real mem = %d\n", ctob(physmem));
385:
386: /*
387: * Check front DIP switch setting
388: */
389: #ifdef DEBUG
390: printf("dipsw = 0x%x\n", dipswitch);
391: #endif
392:
393: /* Check DIP switch 1 - 1 */
394: if ((0x8000 & dipswitch) == 0) {
395: boothowto |= RB_SINGLE;
396: }
397:
398: /* Check DIP switch 1 - 3 */
399: if ((0x2000 & dipswitch) == 0) {
400: boothowto |= RB_ASKNAME;
401: }
402:
403: /* Check DIP switch 1 - 4 */
404: if ((0x1000 & dipswitch) == 0) {
405: boothowto |= RB_CONFIG;
406: }
407:
408: /*
409: * Check frame buffer depth.
410: */
411: switch (hwplanebits) {
412: case 0: /* No frame buffer */
413: case 1:
414: case 4:
415: case 8:
416: break;
417: default:
418: printf("unexpected frame buffer depth = %d\n", hwplanebits);
419: hwplanebits = 0;
420: break;
421: }
422:
423: #if 0 /* just for test */
424: /*
425: * Get boot arguments
426: */
427: {
428: char buf[256];
429: char **p = (volatile char **)0x00001120;
430:
431: strncpy(buf, *p, 256);
432: if (buf[255] != '\0')
433: buf[255] = '\0';
434:
435: printf("boot arg: (0x%x) %s\n", *p, buf);
436: }
437: #endif
438:
439: /*
440: * Find out how much space we need, allocate it,
441: * and then give everything true virtual addresses.
442: */
443: sz = (int)allocsys((caddr_t)0);
444:
445: if ((v = (caddr_t)uvm_km_zalloc(kernel_map, round_page(sz))) == 0)
446: panic("startup: no room for tables");
447: if (allocsys(v) - v != sz)
448: panic("startup: table size inconsistency");
449:
450: /*
451: * Grab the OBIO space that we hardwired in pmap_bootstrap
452: */
453: obiova = OBIO_START;
454: uvm_map(kernel_map, (vaddr_t *)&obiova, OBIO_SIZE,
455: NULL, UVM_UNKNOWN_OFFSET, 0,
456: UVM_MAPFLAG(UVM_PROT_NONE, UVM_PROT_NONE, UVM_INH_NONE,
457: UVM_ADV_NORMAL, 0));
458: if (obiova != OBIO_START)
459: panic("obiova %lx: OBIO not free", obiova);
460:
461: /*
462: * Determine how many buffers to allocate.
463: * We allocate bufcachepercent% of memory for buffer space.
464: */
465: if (bufpages == 0)
466: bufpages = physmem * bufcachepercent / 100;
467:
468: /* Restrict to at most 25% filled kvm */
469: if (bufpages >
470: (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) / PAGE_SIZE / 4)
471: bufpages = (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) /
472: PAGE_SIZE / 4;
473:
474: /*
475: * Allocate a submap for exec arguments. This map effectively
476: * limits the number of processes exec'ing at any time.
477: */
478: minaddr = vm_map_min(kernel_map);
479: exec_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
480: 16 * NCARGS, VM_MAP_PAGEABLE, FALSE, NULL);
481:
482: /*
483: * Allocate map for physio.
484: */
485: phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
486: VM_PHYS_SIZE, 0, FALSE, NULL);
487:
488: printf("avail mem = %ld (%d pages)\n", ptoa(uvmexp.free), uvmexp.free);
489:
490: /*
491: * Set up buffers, so they can be used to read disk labels.
492: */
493: bufinit();
494:
495: /*
496: * Initialize the autovectored interrupt list.
497: */
498: isrinit();
499:
500: /*
501: * Configure the system.
502: */
503: if (boothowto & RB_CONFIG) {
504: #ifdef BOOT_CONFIG
505: user_config();
506: #else
507: printf("kernel does not support -c; continuing..\n");
508: #endif
509: }
510: }
511:
512: /*
513: * Allocate space for system data structures. We are given
514: * a starting virtual address and we return a final virtual
515: * address; along the way we set each data structure pointer.
516: *
517: * We call allocsys() with 0 to find out how much space we want,
518: * allocate that much and fill it with zeroes, and then call
519: * allocsys() again with the correct base virtual address.
520: */
521: caddr_t
522: allocsys(v)
523: caddr_t v;
524: {
525:
526: #define valloc(name, type, num) \
527: v = (caddr_t)(((name) = (type *)v) + (num))
528:
529: #ifdef SYSVMSG
530: valloc(msgpool, char, msginfo.msgmax);
531: valloc(msgmaps, struct msgmap, msginfo.msgseg);
532: valloc(msghdrs, struct msg, msginfo.msgtql);
533: valloc(msqids, struct msqid_ds, msginfo.msgmni);
534: #endif
535:
536: return v;
537: }
538:
539: __dead void
540: boot(howto)
541: int howto;
542: {
543: /* take a snapshot before clobbering any registers */
544: if (curproc && curproc->p_addr)
545: savectx(curpcb);
546:
547: /* If system is cold, just halt. */
548: if (cold) {
549: /* (Unless the user explicitly asked for reboot.) */
550: if ((howto & RB_USERREQ) == 0)
551: howto |= RB_HALT;
552: goto haltsys;
553: }
554:
555: boothowto = howto;
556: if ((howto & RB_NOSYNC) == 0) {
557: vfs_shutdown();
558: /*
559: * If we've been adjusting the clock, the todr
560: * will be out of synch; adjust it now unless
561: * the system was sitting in ddb.
562: */
563: if ((howto & RB_TIMEBAD) == 0)
564: resettodr();
565: else
566: printf("WARNING: not updating battery clock\n");
567: }
568:
569: /* Disable interrupts. */
570: splhigh();
571:
572: /* If rebooting and a dump is requested, do it. */
573: if (howto & RB_DUMP)
574: dumpsys();
575:
576: haltsys:
577: /* Run any shutdown hooks. */
578: doshutdownhooks();
579:
580: /* Luna88k supports automatic powerdown */
581: if ((howto & RB_POWERDOWN) == RB_POWERDOWN) {
582: printf("attempting to power down...\n");
583: powerdown();
584: /* if failed, fall through. */
585: }
586:
587: if (howto & RB_HALT) {
588: printf("halted\n\n");
589: } else {
590: /* Reset all cpus, which causes reboot */
591: *((volatile unsigned *)0x6d000010) = 0;
592: }
593:
594: for (;;); /* to keep compiler happy, and me from going crazy */
595: /*NOTREACHED*/
596: }
597:
598: unsigned dumpmag = 0x8fca0101; /* magic number for savecore */
599: int dumpsize = 0; /* also for savecore */
600: long dumplo = 0;
601: cpu_kcore_hdr_t cpu_kcore_hdr;
602:
603: /*
604: * This is called by configure to set dumplo and dumpsize.
605: * Dumps always skip the first PAGE_SIZE of disk space
606: * in case there might be a disk label stored there.
607: * If there is extra space, put dump at the end to
608: * reduce the chance that swapping trashes it.
609: */
610: void
611: dumpconf(void)
612: {
613: int nblks; /* size of dump area */
614:
615: if (dumpdev == NODEV ||
616: (nblks = (bdevsw[major(dumpdev)].d_psize)(dumpdev)) == 0)
617: return;
618: if (nblks <= ctod(1))
619: return;
620:
621: dumpsize = physmem;
622:
623: /* luna88k only uses a single segment. */
624: cpu_kcore_hdr.ram_segs[0].start = 0;
625: cpu_kcore_hdr.ram_segs[0].size = ctob(physmem);
626: cpu_kcore_hdr.cputype = cputyp;
627:
628: /*
629: * Don't dump on the first block
630: * in case the dump device includes a disk label.
631: */
632: if (dumplo < ctod(1))
633: dumplo = ctod(1);
634:
635: /* Put dump at end of partition, and make it fit. */
636: if (dumpsize + 1 > dtoc(nblks - dumplo))
637: dumpsize = dtoc(nblks - dumplo) - 1;
638: if (dumplo < nblks - ctod(dumpsize) - 1)
639: dumplo = nblks - ctod(dumpsize) - 1;
640: }
641:
642: /*
643: * Doadump comes here after turning off memory management and
644: * getting on the dump stack, either when called above, or by
645: * the auto-restart code.
646: */
647: void
648: dumpsys()
649: {
650: int maj;
651: int psize;
652: daddr64_t blkno; /* current block to write */
653: /* dump routine */
654: int (*dump)(dev_t, daddr64_t, caddr_t, size_t);
655: int pg; /* page being dumped */
656: paddr_t maddr; /* PA being dumped */
657: int error; /* error code from (*dump)() */
658: kcore_seg_t *kseg_p;
659: cpu_kcore_hdr_t *chdr_p;
660: char dump_hdr[dbtob(1)]; /* XXX assume hdr fits in 1 block */
661:
662: extern int msgbufmapped;
663:
664: msgbufmapped = 0;
665:
666: /* Make sure dump device is valid. */
667: if (dumpdev == NODEV)
668: return;
669: if (dumpsize == 0) {
670: dumpconf();
671: if (dumpsize == 0)
672: return;
673: }
674: maj = major(dumpdev);
675: if (dumplo < 0) {
676: printf("\ndump to dev %u,%u not possible\n", maj,
677: minor(dumpdev));
678: return;
679: }
680: dump = bdevsw[maj].d_dump;
681: blkno = dumplo;
682:
683: printf("\ndumping to dev %u,%u offset %ld\n", maj,
684: minor(dumpdev), dumplo);
685:
686: /* Setup the dump header */
687: kseg_p = (kcore_seg_t *)dump_hdr;
688: chdr_p = (cpu_kcore_hdr_t *)&dump_hdr[ALIGN(sizeof(*kseg_p))];
689: bzero(dump_hdr, sizeof(dump_hdr));
690:
691: CORE_SETMAGIC(*kseg_p, KCORE_MAGIC, MID_MACHINE, CORE_CPU);
692: kseg_p->c_size = dbtob(1) - ALIGN(sizeof(*kseg_p));
693: *chdr_p = cpu_kcore_hdr;
694:
695: printf("dump ");
696: psize = (*bdevsw[maj].d_psize)(dumpdev);
697: if (psize == -1) {
698: printf("area unavailable\n");
699: return;
700: }
701:
702: /* Dump the header. */
703: error = (*dump)(dumpdev, blkno++, (caddr_t)dump_hdr, dbtob(1));
704: if (error != 0)
705: goto abort;
706:
707: maddr = (paddr_t)0;
708: for (pg = 0; pg < dumpsize; pg++) {
709: #define NPGMB (1024 * 1024 / PAGE_SIZE)
710: /* print out how many MBs we have dumped */
711: if (pg != 0 && (pg % NPGMB) == 0)
712: printf("%d ", pg / NPGMB);
713: #undef NPGMB
714: pmap_enter(pmap_kernel(), (vaddr_t)vmmap, maddr,
715: VM_PROT_READ, VM_PROT_READ|PMAP_WIRED);
716:
717: error = (*dump)(dumpdev, blkno, vmmap, PAGE_SIZE);
718: if (error == 0) {
719: maddr += PAGE_SIZE;
720: blkno += btodb(PAGE_SIZE);
721: } else
722: break;
723: }
724: abort:
725: switch (error) {
726: case 0:
727: printf("succeeded\n");
728: break;
729:
730: case ENXIO:
731: printf("device bad\n");
732: break;
733:
734: case EFAULT:
735: printf("device not ready\n");
736: break;
737:
738: case EINVAL:
739: printf("area improper\n");
740: break;
741:
742: case EIO:
743: printf("i/o error\n");
744: break;
745:
746: case EINTR:
747: printf("aborted from console\n");
748: break;
749:
750: default:
751: printf("error %d\n", error);
752: break;
753: }
754: }
755:
756: #ifdef MULTIPROCESSOR
757:
758: /*
759: * Secondary CPU early initialization routine.
760: * Determine CPU number and set it, then allocate the idle pcb (and stack).
761: *
762: * Running on a minimal stack here, with interrupts disabled; do nothing fancy.
763: */
764: void
765: secondary_pre_main()
766: {
767: struct cpu_info *ci;
768:
769: set_cpu_number(cmmu_cpu_number());
770: ci = curcpu();
771:
772: /*
773: * Setup CMMUs and translation tables (shared with the master cpu).
774: */
775: pmap_bootstrap_cpu(ci->ci_cpuid);
776:
777: /*
778: * Allocate UPAGES contiguous pages for the idle PCB and stack.
779: */
780: ci->ci_idle_pcb = (struct pcb *)uvm_km_zalloc(kernel_map, USPACE);
781: if (ci->ci_idle_pcb == NULL) {
782: printf("cpu%d: unable to allocate idle stack\n", ci->ci_cpuid);
783: }
784: }
785:
786: /*
787: * Further secondary CPU initialization.
788: *
789: * We are now running on our idle stack, with proper page tables.
790: * There is nothing to do but display some details about the CPU and its CMMUs.
791: */
792: void
793: secondary_main()
794: {
795: struct cpu_info *ci = curcpu();
796:
797: cpu_configuration_print(0);
798: ncpus++;
799:
800: microuptime(&ci->ci_schedstate.spc_runtime);
801:
802: /*
803: * Upon return, the secondary cpu bootstrap code in locore will
804: * enter the idle loop, waiting for some food to process on this
805: * processor.
806: */
807: }
808:
809: #endif /* MULTIPROCESSOR */
810:
811: /*
812: * Device interrupt handler for LUNA88K
813: */
814:
815: void
816: luna88k_ext_int(u_int v, struct trapframe *eframe)
817: {
818: int cpu = cpu_number();
819: unsigned int cur_mask, cur_int;
820: unsigned int level, old_spl;
821:
822: cur_mask = *int_mask_reg[cpu];
823: old_spl = luna88k_curspl[cpu];
824: eframe->tf_mask = old_spl;
825:
826: cur_int = cur_mask >> 29;
827:
828: if (cur_int == 0) {
829: /*
830: * Spurious interrupts - may be caused by debug output clearing
831: * serial port interrupts.
832: */
833: #ifdef DEBUG
834: printf("luna88k_ext_int(): Spurious interrupts?\n");
835: #endif
836: flush_pipeline();
837: goto out;
838: }
839:
840: uvmexp.intrs++;
841:
842: /*
843: * We want to service all interrupts marked in the IST register
844: * They are all valid because the mask would have prevented them
845: * from being generated otherwise. We will service them in order of
846: * priority.
847: */
848:
849: /* XXX: This is very rough. Should be considered more. (aoyama) */
850: do {
851: level = (cur_int > old_spl ? cur_int : old_spl);
852:
853: #ifdef DEBUG
854: if (level > 7 || (char)level < 0) {
855: panic("int level (%x) is not between 0 and 7", level);
856: }
857: #endif
858:
859: setipl(level);
860:
861: set_psr(get_psr() & ~PSR_IND);
862:
863: switch(cur_int) {
864: case CLOCK_INT_LEVEL:
865: clockintr((void *)eframe);
866: break;
867: case 5:
868: case 4:
869: case 3:
870: isrdispatch_autovec(cur_int);
871: break;
872: default:
873: printf("luna88k_ext_int(): level %d interrupt.\n", cur_int);
874: break;
875: }
876: } while ((cur_int = (*int_mask_reg[cpu]) >> 29) != 0);
877:
878: out:
879: /*
880: * process any remaining data access exceptions before
881: * returning to assembler
882: */
883: if (eframe->tf_dmt0 & DMT_VALID)
884: m88100_trap(T_DATAFLT, eframe);
885:
886: /*
887: * Disable interrupts before returning to assembler, the spl will
888: * be restored later.
889: */
890: set_psr(get_psr() | PSR_IND);
891: }
892:
893: int
894: cpu_exec_aout_makecmds(p, epp)
895: struct proc *p;
896: struct exec_package *epp;
897: {
898:
899: return (ENOEXEC);
900: }
901:
902: int
903: sys_sysarch(p, v, retval)
904: struct proc *p;
905: void *v;
906: register_t *retval;
907: {
908: #if 0
909: struct sys_sysarch_args /* {
910: syscallarg(int) op;
911: syscallarg(char *) parm;
912: } */ *uap = v;
913: #endif
914:
915: return (ENOSYS);
916: }
917:
918: /*
919: * machine dependent system variables.
920: */
921:
922: int
923: cpu_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
924: int *name;
925: u_int namelen;
926: void *oldp;
927: size_t *oldlenp;
928: void *newp;
929: size_t newlen;
930: struct proc *p;
931: {
932: dev_t consdev;
933:
934: /* all sysctl names are this level are terminal */
935: if (namelen != 1)
936: return (ENOTDIR); /* overloaded */
937:
938: switch (name[0]) {
939: case CPU_CONSDEV:
940: if (cn_tab != NULL)
941: consdev = cn_tab->cn_dev;
942: else
943: consdev = NODEV;
944: return (sysctl_rdstruct(oldp, oldlenp, newp, &consdev,
945: sizeof consdev));
946: default:
947: return (EOPNOTSUPP);
948: }
949: /*NOTREACHED*/
950: }
951:
952: /*
953: * Called from locore.S during boot,
954: * this is the first C code that's run.
955: */
956: void
957: luna88k_bootstrap()
958: {
959: extern int kernelstart;
960: extern struct consdev *cn_tab;
961: extern struct cmmu_p cmmu8820x;
962: extern char *end;
963: #ifndef MULTIPROCESSOR
964: cpuid_t master_cpu;
965: #endif
966: cpuid_t cpu;
967: extern void m8820x_initialize_cpu(cpuid_t);
968: extern void m8820x_set_sapr(cpuid_t, apr_t);
969: extern void cpu_boot_secondary_processors(void);
970:
971: cmmu = &cmmu8820x;
972:
973: /* clear and disable all interrupts */
974: *int_mask_reg[0] = 0;
975: *int_mask_reg[1] = 0;
976: *int_mask_reg[2] = 0;
977: *int_mask_reg[3] = 0;
978:
979: /* startup fake console driver. It will be replaced by consinit() */
980: cn_tab = &romttycons;
981:
982: uvmexp.pagesize = PAGE_SIZE;
983: uvm_setpagesize();
984:
985: first_addr = round_page((vaddr_t)&end); /* XXX temp until symbols */
986: last_addr = size_memory();
987: physmem = btoc(last_addr);
988:
989: setup_board_config();
990: master_cpu = cmmu_init();
991: set_cpu_number(master_cpu);
992:
993: m88100_apply_patches();
994:
995: /*
996: * Now that set_cpu_number() set us with a valid cpu_info pointer,
997: * we need to initialize p_addr and curpcb before autoconf, for the
998: * fault handler to behave properly [except for badaddr() faults,
999: * which can be taken care of without a valid curcpu()].
1000: */
1001: proc0.p_addr = proc0paddr;
1002: curproc = &proc0;
1003: curpcb = &proc0paddr->u_pcb;
1004:
1005: avail_start = first_addr;
1006: avail_end = last_addr;
1007:
1008: /*
1009: * Steal MSGBUFSIZE at the top of physical memory for msgbuf
1010: */
1011: avail_end -= round_page(MSGBUFSIZE);
1012:
1013: #ifdef DEBUG
1014: printf("LUNA88K boot: memory from 0x%x to 0x%x\n",
1015: avail_start, avail_end);
1016: #endif
1017: pmap_bootstrap((vaddr_t)trunc_page((unsigned)&kernelstart));
1018:
1019: /*
1020: * Tell the VM system about available physical memory.
1021: * luna88k only has one segment.
1022: */
1023: uvm_page_physload(atop(avail_start), atop(avail_end),
1024: atop(avail_start), atop(avail_end),VM_FREELIST_DEFAULT);
1025:
1026: /* Initialize the "u-area" pages. */
1027: bzero((caddr_t)curpcb, USPACE);
1028:
1029: /*
1030: * On the luna88k, secondary processors are not disabled while the
1031: * kernel is initializing. We just initialized the CMMUs tied to the
1032: * currently-running CPU; initialize the others with similar settings
1033: * as well, after calling pmap_bootstrap() above.
1034: */
1035: for (cpu = 0; cpu < max_cpus; cpu++) {
1036: if (cpu == master_cpu)
1037: continue;
1038: if (m88k_cpus[cpu].ci_alive == 0)
1039: continue;
1040: m8820x_initialize_cpu(cpu);
1041: cmmu_set_sapr(cpu, kernel_pmap->pm_apr);
1042: }
1043: /* Release the cpu_mutex */
1044: cpu_boot_secondary_processors();
1045:
1046: #ifdef DEBUG
1047: printf("leaving luna88k_bootstrap()\n");
1048: #endif
1049: }
1050:
1051: /*
1052: * Rom console routines:
1053: * Enables printing of boot messages before consinit().
1054: */
1055:
1056: #define __ROM_FUNC_TABLE ((int **)0x00001100)
1057: #define ROMGETC() (*(int (*)(void))__ROM_FUNC_TABLE[3])()
1058: #define ROMPUTC(x) (*(void (*)(int))__ROM_FUNC_TABLE[4])(x)
1059:
1060: void
1061: romttycnprobe(cp)
1062: struct consdev *cp;
1063: {
1064: cp->cn_dev = makedev(14, 0);
1065: cp->cn_pri = CN_NORMAL;
1066: }
1067:
1068: void
1069: romttycninit(cp)
1070: struct consdev *cp;
1071: {
1072: /* Nothing to do */
1073: }
1074:
1075: int
1076: romttycngetc(dev)
1077: dev_t dev;
1078: {
1079: int s, c;
1080:
1081: do {
1082: s = splhigh();
1083: c = ROMGETC();
1084: splx(s);
1085: } while (c == -1);
1086: return c;
1087: }
1088:
1089: void
1090: romttycnputc(dev, c)
1091: dev_t dev;
1092: int c;
1093: {
1094: int s;
1095:
1096: #if 0
1097: if ((char)c == '\n')
1098: ROMPUTC('\r');
1099: #endif
1100: s = splhigh();
1101: ROMPUTC(c);
1102: splx(s);
1103: }
1104:
1105: /* taken from NetBSD/luna68k */
1106: void
1107: microtime(tvp)
1108: register struct timeval *tvp;
1109: {
1110: int s = splclock();
1111: static struct timeval lasttime;
1112:
1113: *tvp = time;
1114: #ifdef notdef
1115: tvp->tv_usec += clkread();
1116: while (tvp->tv_usec >= 1000000) {
1117: tvp->tv_sec++;
1118: tvp->tv_usec -= 1000000;
1119: }
1120: #endif
1121: if (tvp->tv_sec == lasttime.tv_sec &&
1122: tvp->tv_usec <= lasttime.tv_usec &&
1123: (tvp->tv_usec = lasttime.tv_usec + 1) >= 1000000) {
1124: tvp->tv_sec++;
1125: tvp->tv_usec -= 1000000;
1126: }
1127: lasttime = *tvp;
1128: splx(s);
1129: }
1130:
1131: /* powerdown */
1132:
1133: struct pio {
1134: volatile u_int8_t portA;
1135: volatile unsigned : 24;
1136: volatile u_int8_t portB;
1137: volatile unsigned : 24;
1138: volatile u_int8_t portC;
1139: volatile unsigned : 24;
1140: volatile u_int8_t cntrl;
1141: volatile unsigned : 24;
1142: };
1143:
1144: #define PIO1_POWER 0x04
1145:
1146: #define PIO1_ENABLE 0x01
1147: #define PIO1_DISABLE 0x00
1148:
1149: void
1150: powerdown(void)
1151: {
1152: struct pio *p1 = (struct pio *)OBIO_PIO1_BASE;
1153:
1154: DELAY(100000);
1155: p1->cntrl = (PIO1_POWER << 1) | PIO1_DISABLE;
1156: *(volatile u_int8_t *)&p1->portC;
1157: }
1158:
1159: /* Get data from FUSE ROM */
1160:
1161: void
1162: get_fuse_rom_data(void)
1163: {
1164: int i;
1165: struct fuse_rom_byte *p = (struct fuse_rom_byte *)FUSE_ROM_ADDR;
1166:
1167: for (i = 0; i < FUSE_ROM_BYTES; i++) {
1168: fuse_rom_data[i] =
1169: (char)((((p->h) >> 24) & 0x000000f0) |
1170: (((p->l) >> 28) & 0x0000000f));
1171: p++;
1172: }
1173: }
1174:
1175: /* Get data from NVRAM */
1176:
1177: void
1178: get_nvram_data(void)
1179: {
1180: int i, j;
1181: u_int8_t *page;
1182: char buf[NVSYMLEN], *data;
1183:
1184: if (machtype == LUNA_88K) {
1185: data = (char *)(NVRAM_ADDR + 0x80);
1186:
1187: for (i = 0; i < NNVSYM; i++) {
1188: for (j = 0; j < NVSYMLEN; j++) {
1189: buf[j] = *data;
1190: data += 4;
1191: }
1192: strlcpy(nvram[i].symbol, buf, sizeof(nvram[i].symbol));
1193:
1194: for (j = 0; j < NVVALLEN; j++) {
1195: buf[j] = *data;
1196: data += 4;
1197: }
1198: strlcpy(nvram[i].value, buf, sizeof(nvram[i].value));
1199: }
1200: } else if (machtype == LUNA_88K2) {
1201: page = (u_int8_t *)(NVRAM_ADDR_88K2 + 0x20);
1202:
1203: for (i = 0; i < NNVSYM; i++) {
1204: *page = (u_int8_t)i;
1205:
1206: data = (char *)NVRAM_ADDR_88K2;
1207: strlcpy(nvram[i].symbol, data, sizeof(nvram[i].symbol));
1208:
1209: data = (char *)(NVRAM_ADDR_88K2 + 0x10);
1210: strlcpy(nvram[i].value, data, sizeof(nvram[i].value));
1211: }
1212: }
1213: }
1214:
1215: char *
1216: nvram_by_symbol(symbol)
1217: char *symbol;
1218: {
1219: char *value;
1220: int i;
1221:
1222: value = NULL;
1223:
1224: for (i = 0; i < NNVSYM; i++) {
1225: if (strncmp(nvram[i].symbol, symbol, NVSYMLEN) == 0) {
1226: value = nvram[i].value;
1227: break;
1228: }
1229: }
1230:
1231: return value;
1232: }
1233:
1234: void
1235: setlevel(unsigned int level)
1236: {
1237: unsigned int set_value;
1238: int cpu = cpu_number();
1239:
1240: set_value = int_set_val[level];
1241:
1242: #ifdef MULTIPROCESSOR
1243: if (cpu != master_cpu)
1244: set_value &= INT_SLAVE_MASK;
1245: #endif
1246:
1247: *int_mask_reg[cpu] = set_value;
1248: luna88k_curspl[cpu] = level;
1249: }
1250:
1251: u_int
1252: getipl(void)
1253: {
1254: u_int curspl, psr;
1255:
1256: disable_interrupt(psr);
1257: curspl = luna88k_curspl[cpu_number()];
1258: set_psr(psr);
1259: return curspl;
1260: }
1261:
1262: unsigned
1263: setipl(unsigned level)
1264: {
1265: unsigned int curspl, psr;
1266:
1267: disable_interrupt(psr);
1268: curspl = luna88k_curspl[cpu_number()];
1269: setlevel(level);
1270:
1271: /*
1272: * The flush pipeline is required to make sure the above write gets
1273: * through the data pipe and to the hardware; otherwise, the next
1274: * bunch of instructions could execute at the wrong spl protection.
1275: */
1276: flush_pipeline();
1277:
1278: set_psr(psr);
1279: return curspl;
1280: }
1281:
1282: unsigned
1283: raiseipl(unsigned level)
1284: {
1285: unsigned int curspl, psr;
1286:
1287: disable_interrupt(psr);
1288: curspl = luna88k_curspl[cpu_number()];
1289: if (curspl < level)
1290: setlevel(level);
1291:
1292: /*
1293: * The flush pipeline is required to make sure the above write gets
1294: * through the data pipe and to the hardware; otherwise, the next
1295: * bunch of instructions could execute at the wrong spl protection.
1296: */
1297: flush_pipeline();
1298:
1299: set_psr(psr);
1300: return curspl;
1301: }
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 / luna88k / luna88k