![[BACK]](/icons/back.gif){kind=icon}
Return to Locore.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / macppc / stand|
Return to Locore.c CVS log | Up to [local] / sys / arch / macppc / stand |
1.1 nbrk 1: /* $OpenBSD: Locore.c,v 1.13 2007/06/23 18:51:45 drahn Exp $ */
2: /* $NetBSD: Locore.c,v 1.1 1997/04/16 20:29:11 thorpej Exp $ */
3:
4: /*
5: * Copyright (C) 1995, 1996 Wolfgang Solfrank.
6: * Copyright (C) 1995, 1996 TooLs GmbH.
7: * All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed by TooLs GmbH.
20: * 4. The name of TooLs GmbH may not be used to endorse or promote products
21: * derived from this software without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26: * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
28: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
29: * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
30: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
31: * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
32: * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33: */
34:
35: #include <lib/libsa/stand.h>
36: #include <macppc/stand/openfirm.h>
37: #include <dev/cons.h>
38:
39:
40: /*
41: #include "machine/cpu.h"
42: */
43:
44: #define ENABLE_DECREMENTER_WORKAROUND
45:
46: static int (*openfirmware)(void *);
47:
48: static void setup(void);
49:
50: asm (".text; .globl _entry; _entry: .long _start,0,0");
51: asm(" .text \n"
52: " .globl bat_init \n"
53: "bat_init: \n"
54: " \n"
55: " mfmsr 8 \n"
56: " li 0,0 \n"
57: " mtmsr 0 \n"
58: " isync \n"
59: " \n"
60: " mtibatu 0,0 \n"
61: " mtibatu 1,0 \n"
62: " mtibatu 2,0 \n"
63: " mtibatu 3,0 \n"
64: " mtdbatu 0,0 \n"
65: " mtdbatu 1,0 \n"
66: " mtdbatu 2,0 \n"
67: " mtdbatu 3,0 \n"
68: " \n"
69: " li 9,0x12 \n" /* BATL(0, BAT_M, BAT_PP_RW) */
70: " mtibatl 0,9 \n"
71: " mtdbatl 0,9 \n"
72: " li 9,0x1ffe \n" /* BATU(0, BAT_BL_256M, BAT_Vs) */
73: " mtibatu 0,9 \n"
74: " mtdbatu 0,9 \n"
75: " isync \n"
76: " \n"
77: " mtmsr 8 \n"
78: " isync \n"
79: " blr \n");
80:
81: #ifdef XCOFF_GLUE
82: static int stack[8192/4 + 4] __attribute__((__used__));
83: #endif
84:
85: __dead void
86: _start(void *vpd, int res, int (*openfirm)(void *), char *arg, int argl)
87: {
88: extern char etext[];
89:
90: #ifdef XCOFF_GLUE
91: asm(
92: "sync \n"
93: "isync \n"
94: "lis %r1,stack@ha \n"
95: "addi %r1,%r1,stack@l \n"
96: "addi %r1,%r1,8192 \n");
97: #endif
98: syncicache((void *)RELOC, etext - (char *)RELOC);
99:
100: bat_init();
101: openfirmware = openfirm; /* Save entry to Open Firmware */
102: #ifdef ENABLE_DECREMENTER_WORKAROUND
103: patch_dec_intr();
104: #endif
105: setup();
106: main(arg, argl);
107: exit();
108: }
109:
110: #ifdef ENABLE_DECREMENTER_WORKAROUND
111: void handle_decr_intr();
112: __asm ( " .globl handle_decr_intr\n"
113: " .type handle_decr_intr@function\n"
114: "handle_decr_intr:\n"
115: " rfi\n");
116:
117:
118: patch_dec_intr()
119: {
120: int time;
121: unsigned int *decr_intr = (unsigned int *)0x900;
122: unsigned int br_instr;
123:
124: /* this hack is to prevent unexpected Decrementer Exceptions
125: * when Apple openfirmware enables interrupts
126: */
127: time = 0x40000000;
128: asm("mtdec %0" :: "r"(time));
129:
130: /* we assume that handle_decr_intr is in the first 128 Meg */
131: br_instr = (18 << 23) | (unsigned int)handle_decr_intr;
132: *decr_intr = br_instr;
133: }
134: #endif
135:
136: __dead void
137: _rtt()
138: {
139: static struct {
140: char *name;
141: int nargs;
142: int nreturns;
143: } args = {
144: "exit",
145: 0,
146: 0
147: };
148:
149: openfirmware(&args);
150: while (1); /* just in case */
151: }
152:
153: int
154: OF_finddevice(char *name)
155: {
156: static struct {
157: char *name;
158: int nargs;
159: int nreturns;
160: char *device;
161: int phandle;
162: } args = {
163: "finddevice",
164: 1,
165: 1,
166: };
167:
168: args.device = name;
169: if (openfirmware(&args) == -1)
170: return -1;
171: return args.phandle;
172: }
173:
174: int
175: OF_instance_to_package(int ihandle)
176: {
177: static struct {
178: char *name;
179: int nargs;
180: int nreturns;
181: int ihandle;
182: int phandle;
183: } args = {
184: "instance-to-package",
185: 1,
186: 1,
187: };
188:
189: args.ihandle = ihandle;
190: if (openfirmware(&args) == -1)
191: return -1;
192: return args.phandle;
193: }
194:
195: int
196: OF_getprop(int handle, char *prop, void *buf, int buflen)
197: {
198: static struct {
199: char *name;
200: int nargs;
201: int nreturns;
202: int phandle;
203: char *prop;
204: void *buf;
205: int buflen;
206: int size;
207: } args = {
208: "getprop",
209: 4,
210: 1,
211: };
212:
213: args.phandle = handle;
214: args.prop = prop;
215: args.buf = buf;
216: args.buflen = buflen;
217: if (openfirmware(&args) == -1)
218: return -1;
219: return args.size;
220: }
221:
222: int
223: OF_open(char *dname)
224: {
225: static struct {
226: char *name;
227: int nargs;
228: int nreturns;
229: char *dname;
230: int handle;
231: } args = {
232: "open",
233: 1,
234: 1,
235: };
236:
237: args.dname = dname;
238: if (openfirmware(&args) == -1)
239: return -1;
240: return args.handle;
241: }
242:
243: void
244: OF_close(int handle)
245: {
246: static struct {
247: char *name;
248: int nargs;
249: int nreturns;
250: int handle;
251: } args = {
252: "close",
253: 1,
254: 0,
255: };
256:
257: args.handle = handle;
258: openfirmware(&args);
259: }
260:
261: int
262: OF_write(int handle, void *addr, int len)
263: {
264: static struct {
265: char *name;
266: int nargs;
267: int nreturns;
268: int ihandle;
269: void *addr;
270: int len;
271: int actual;
272: } args = {
273: "write",
274: 3,
275: 1,
276: };
277:
278: args.ihandle = handle;
279: args.addr = addr;
280: args.len = len;
281: if (openfirmware(&args) == -1)
282: return -1;
283: return args.actual;
284: }
285:
286: int
287: OF_read(int handle, void *addr, int len)
288: {
289: static struct {
290: char *name;
291: int nargs;
292: int nreturns;
293: int ihandle;
294: void *addr;
295: int len;
296: int actual;
297: } args = {
298: "read",
299: 3,
300: 1,
301: };
302:
303: args.ihandle = handle;
304: args.addr = addr;
305: args.len = len;
306: if (openfirmware(&args) == -1)
307: return -1;
308: return args.actual;
309: }
310:
311: int
312: OF_seek(int handle, u_quad_t pos)
313: {
314: static struct {
315: char *name;
316: int nargs;
317: int nreturns;
318: int handle;
319: int poshi;
320: int poslo;
321: int status;
322: } args = {
323: "seek",
324: 3,
325: 1,
326: };
327:
328: args.handle = handle;
329: args.poshi = (int)(pos >> 32);
330: args.poslo = (int)pos;
331: if (openfirmware(&args) == -1)
332: return -1;
333: return args.status;
334: }
335:
336: void *
337: OF_claim(void *virt, u_int size, u_int align)
338: {
339: static struct {
340: char *name;
341: int nargs;
342: int nreturns;
343: void *virt;
344: u_int size;
345: u_int align;
346: void *baseaddr;
347: } args = {
348: "claim",
349: 3,
350: 1,
351: };
352:
353: args.virt = virt;
354: args.size = size;
355: args.align = align;
356: if (openfirmware(&args) == -1)
357: return (void *)-1;
358: if (virt != 0)
359: return virt;
360: return args.baseaddr;
361: }
362:
363: void
364: OF_release(void *virt, u_int size)
365: {
366: static struct {
367: char *name;
368: int nargs;
369: int nreturns;
370: void *virt;
371: u_int size;
372: } args = {
373: "release",
374: 2,
375: 0,
376: };
377:
378: args.virt = virt;
379: args.size = size;
380: openfirmware(&args);
381: }
382:
383: int
384: OF_milliseconds()
385: {
386: static struct {
387: char *name;
388: int nargs;
389: int nreturns;
390: int ms;
391: } args = {
392: "milliseconds",
393: 0,
394: 1,
395: };
396:
397: openfirmware(&args);
398: return args.ms;
399: }
400:
401: #ifdef __notyet__
402: void
403: OF_chain(void *virt, u_int size, void (*entry)(), void *arg, u_int len)
404: {
405: static struct {
406: char *name;
407: int nargs;
408: int nreturns;
409: void *virt;
410: u_int size;
411: void (*entry)();
412: void *arg;
413: u_int len;
414: } args = {
415: "chain",
416: 5,
417: 0,
418: };
419:
420: args.virt = virt;
421: args.size = size;
422: args.entry = entry;
423: args.arg = arg;
424: args.len = len;
425: openfirmware(&args);
426: }
427: #else
428: void
429: OF_chain(void *virt, u_int size, void (*entry)(), void *arg, u_int len)
430: {
431: /*
432: * This is a REALLY dirty hack till the firmware gets this going
433: OF_release(virt, size);
434: */
435: entry(0, 0, openfirmware, arg, len);
436: }
437: #endif
438:
439: int
440: OF_call_method(char *method, int ihandle, int nargs, int nreturns, ...)
441: {
442: va_list ap;
443: static struct {
444: char *name;
445: int nargs;
446: int nreturns;
447: char *method;
448: int ihandle;
449: int args_n_results[12];
450: } args = {
451: "call-method",
452: 2,
453: 1,
454: };
455: int *ip, n;
456:
457: if (nargs > 6)
458: return -1;
459: args.nargs = nargs + 2;
460: args.nreturns = nreturns + 1;
461: args.method = method;
462: args.ihandle = ihandle;
463: va_start(ap, nreturns);
464: for (ip = args.args_n_results + (n = nargs); --n >= 0;)
465: *--ip = va_arg(ap, int);
466:
467: if (openfirmware(&args) == -1) {
468: va_end(ap);
469: return -1;
470: }
471: if (args.args_n_results[nargs]) {
472: va_end(ap);
473: return args.args_n_results[nargs];
474: }
475: for (ip = args.args_n_results + nargs + (n = args.nreturns); --n > 0;)
476: *va_arg(ap, int *) = *--ip;
477: va_end(ap);
478: return 0;
479: }
480:
481: static int stdin;
482: static int stdout;
483:
484: static void
485: setup()
486: {
487: int chosen;
488:
489: if ((chosen = OF_finddevice("/chosen")) == -1)
490: _rtt();
491: if (OF_getprop(chosen, "stdin", &stdin, sizeof(stdin)) != sizeof(stdin)
492: || OF_getprop(chosen, "stdout", &stdout, sizeof(stdout)) !=
493: sizeof(stdout))
494: _rtt();
495: if (stdout == 0) {
496: /* screen should be console, but it is not open */
497: stdout = OF_open("screen");
498: }
499: }
500:
501: void
502: putchar(int c)
503: {
504: char ch = c;
505: if (c == '\177') {
506: ch = '\b';
507: OF_write(stdout, &ch, 1);
508: ch = ' ';
509: OF_write(stdout, &ch, 1);
510: ch = '\b';
511: }
512: if (c == '\n')
513: putchar('\r');
514: OF_write(stdout, &ch, 1);
515: }
516:
517: int
518: getchar()
519: {
520: int c = cngetc();
521:
522: if (c == '\r')
523: c = '\n';
524:
525: if ((c < ' ' && c != '\n') || c == '\177')
526: return(c);
527:
528: putchar(c);
529:
530: return(c);
531: }
532:
533: void
534: ofc_probe(struct consdev *cn)
535: {
536: cn->cn_pri = CN_NORMAL;
537: cn->cn_dev = makedev(0,0); /* WTF */
538: }
539:
540:
541: void
542: ofc_init(struct consdev *cn)
543: {
544: }
545:
546: char buffered_char;
547: int
548: ofc_getc(dev_t dev)
549: {
550: u_int8_t ch;
551: int l;
552:
553: if (dev & 0x80) {
554: if (buffered_char != 0)
555: return 1;
556:
557: l = OF_read(stdin, &ch, 1);
558: if (l == 1) {
559: buffered_char = ch;
560: return 1;
561: }
562: return 0;
563: }
564:
565: if (buffered_char != 0) {
566: ch = buffered_char;
567: buffered_char = 0;
568: return ch;
569: }
570:
571: while ((l = OF_read(stdin, &ch, 1)) != 1)
572: if (l != -2 && l != 0)
573: return 0;
574: return ch;
575:
576: }
577:
578: void
579: ofc_putc(dev_t dev, int c)
580: {
581: char ch;
582:
583: ch = 'a';
584: OF_write(stdout, &ch, 1);
585: ch = c;
586: if (c == '\177' && c == '\b') {
587: ch = 'A';
588: }
589: OF_write(stdout, &ch, 1);
590: }
591:
592:
593: void
594: machdep()
595: {
596: cninit();
597: }