![[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 / sparc64 / stand / ofwboot|
Return to Locore.c CVS log | Up to [local] / sys / arch / sparc64 / stand / ofwboot |
1.1 nbrk 1: /* $OpenBSD: Locore.c,v 1.7 2007/01/16 14:39:57 tsi Exp $ */
2: /* $NetBSD: Locore.c,v 1.1 2000/08/20 14:58:36 mrg 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 "openfirm.h"
37:
38: #include <machine/cpu.h>
39:
40: static vaddr_t OF_claim_virt(vaddr_t vaddr, int len);
41: static vaddr_t OF_alloc_virt(int len, int align);
42: static int OF_free_virt(vaddr_t vaddr, int len);
43: static vaddr_t OF_map_phys(paddr_t paddr, off_t size, vaddr_t vaddr, int mode);
44: static paddr_t OF_alloc_phys(int len, int align);
45: static int OF_free_phys(paddr_t paddr, int len);
46:
47: extern int openfirmware(void *);
48:
49: void setup(void);
50:
51: #if 0
52: #ifdef XCOFF_GLUE
53: asm (".text; .globl _entry; _entry: .long _start,0,0");
54: #endif
55:
56: __dead void
57: _start(vpd, res, openfirm, arg, argl)
58: void *vpd;
59: int res;
60: int (*openfirm)(void *);
61: char *arg;
62: int argl;
63: {
64: extern char etext[];
65:
66: #ifdef FIRMWORKSBUGS
67: syncicache((void *)RELOC, etext - (char *)RELOC);
68: #endif
69: openfirmware = openfirm; /* Save entry to Open Firmware */
70: setup();
71: main(arg, argl);
72: exit();
73: }
74: #endif
75:
76: __dead void
77: _rtt()
78: {
79: struct {
80: cell_t name;
81: cell_t nargs;
82: cell_t nreturns;
83: } args;
84:
85: args.name = ADR2CELL("exit");
86: args.nargs = 0;
87: args.nreturns = 0;
88: openfirmware(&args);
89: while (1); /* just in case */
90: }
91:
92: void
93: OF_enter()
94: {
95: struct {
96: cell_t name;
97: cell_t nargs;
98: cell_t nreturns;
99: } args;
100:
101: args.name = ADR2CELL("enter");
102: args.nargs = 0;
103: args.nreturns = 0;
104: openfirmware(&args);
105: }
106:
107: int
108: OF_finddevice(name)
109: char *name;
110: {
111: struct {
112: cell_t name;
113: cell_t nargs;
114: cell_t nreturns;
115: cell_t device;
116: cell_t phandle;
117: } args;
118:
119: args.name = ADR2CELL("finddevice");
120: args.nargs = 1;
121: args.nreturns = 1;
122: args.device = ADR2CELL(name);
123: if (openfirmware(&args) == -1)
124: return -1;
125: return args.phandle;
126: }
127:
128: int
129: OF_instance_to_package(ihandle)
130: int ihandle;
131: {
132: struct {
133: cell_t name;
134: cell_t nargs;
135: cell_t nreturns;
136: cell_t ihandle;
137: cell_t phandle;
138: } args;
139:
140: args.name = ADR2CELL("instance-to-package");
141: args.nargs = 1;
142: args.nreturns = 1;
143: args.ihandle = HDL2CELL(ihandle);
144: if (openfirmware(&args) == -1)
145: return -1;
146: return args.phandle;
147: }
148:
149: int
150: OF_getprop(handle, prop, buf, buflen)
151: int handle;
152: char *prop;
153: void *buf;
154: int buflen;
155: {
156: struct {
157: cell_t name;
158: cell_t nargs;
159: cell_t nreturns;
160: cell_t phandle;
161: cell_t prop;
162: cell_t buf;
163: cell_t buflen;
164: cell_t size;
165: } args;
166:
167: args.name = ADR2CELL("getprop");
168: args.nargs = 4;
169: args.nreturns = 1;
170: args.phandle = HDL2CELL(handle);
171: args.prop = ADR2CELL(prop);
172: args.buf = ADR2CELL(buf);
173: args.buflen = buflen;
174: if (openfirmware(&args) == -1)
175: return -1;
176: return args.size;
177: }
178:
179: #ifdef __notyet__ /* Has a bug on FirePower */
180: int
181: OF_setprop(handle, prop, buf, len)
182: u_int handle;
183: char *prop;
184: void *buf;
185: int len;
186: {
187: struct {
188: cell_t name;
189: cell_t nargs;
190: cell_t nreturns;
191: cell_t phandle;
192: cell_t prop;
193: cell_t buf;
194: cell_t len;
195: cell_t size;
196: } args;
197:
198: args.name = ADR2CELL("setprop");
199: args.nargs = 4;
200: args.nreturns = 1;
201: args.phandle = HDL2CELL(handle);
202: args.prop = ADR2CELL(prop);
203: args.buf = ADR2CELL(buf);
204: args.len = len;
205: if (openfirmware(&args) == -1)
206: return -1;
207: return args.size;
208: }
209: #endif
210:
211: int
212: OF_open(dname)
213: char *dname;
214: {
215: struct {
216: cell_t name;
217: cell_t nargs;
218: cell_t nreturns;
219: cell_t dname;
220: cell_t handle;
221: } args;
222:
223: args.name = ADR2CELL("open");
224: args.nargs = 1;
225: args.nreturns = 1;
226: args.dname = ADR2CELL(dname);
227: if (openfirmware(&args) == -1 ||
228: args.handle == 0)
229: return -1;
230: return args.handle;
231: }
232:
233: void
234: OF_close(handle)
235: int handle;
236: {
237: struct {
238: cell_t name;
239: cell_t nargs;
240: cell_t nreturns;
241: cell_t handle;
242: } args;
243:
244: args.name = ADR2CELL("close");
245: args.nargs = 1;
246: args.nreturns = 1;
247: args.handle = HDL2CELL(handle);
248: openfirmware(&args);
249: }
250:
251: int
252: OF_write(handle, addr, len)
253: int handle;
254: void *addr;
255: int len;
256: {
257: struct {
258: cell_t name;
259: cell_t nargs;
260: cell_t nreturns;
261: cell_t ihandle;
262: cell_t addr;
263: cell_t len;
264: cell_t actual;
265: } args;
266:
267: args.name = ADR2CELL("write");
268: args.nargs = 3;
269: args.nreturns = 1;
270: args.ihandle = HDL2CELL(handle);
271: args.addr = ADR2CELL(addr);
272: args.len = len;
273: if (openfirmware(&args) == -1)
274: return -1;
275: return args.actual;
276: }
277:
278: int
279: OF_read(handle, addr, len)
280: int handle;
281: void *addr;
282: int len;
283: {
284: struct {
285: cell_t name;
286: cell_t nargs;
287: cell_t nreturns;
288: cell_t ihandle;
289: cell_t addr;
290: cell_t len;
291: cell_t actual;
292: } args;
293:
294: args.name = ADR2CELL("read");
295: args.nargs = 3;
296: args.nreturns = 1;
297: args.ihandle = HDL2CELL(handle);
298: args.addr = ADR2CELL(addr);
299: args.len = len;
300: if (openfirmware(&args) == -1) {
301: return -1;
302: }
303: return args.actual;
304: }
305:
306: int
307: OF_seek(handle, pos)
308: int handle;
309: u_quad_t pos;
310: {
311: struct {
312: cell_t name;
313: cell_t nargs;
314: cell_t nreturns;
315: cell_t handle;
316: cell_t poshi;
317: cell_t poslo;
318: cell_t status;
319: } args;
320:
321: args.name = ADR2CELL("seek");
322: args.nargs = 3;
323: args.nreturns = 1;
324: args.handle = HDL2CELL(handle);
325: args.poshi = HDQ2CELL_HI(pos);
326: args.poslo = HDQ2CELL_LO(pos);
327: if (openfirmware(&args) == -1) {
328: return -1;
329: }
330: return args.status;
331: }
332:
333: void
334: OF_release(virt, size)
335: void *virt;
336: u_int size;
337: {
338: struct {
339: cell_t name;
340: cell_t nargs;
341: cell_t nreturns;
342: cell_t virt;
343: cell_t size;
344: } args;
345:
346: args.name = ADR2CELL("release");
347: args.nargs = 2;
348: args.nreturns = 0;
349: args.virt = ADR2CELL(virt);
350: args.size = size;
351: openfirmware(&args);
352: }
353:
354: int
355: OF_milliseconds()
356: {
357: struct {
358: cell_t name;
359: cell_t nargs;
360: cell_t nreturns;
361: cell_t ms;
362: } args;
363:
364: args.name = ADR2CELL("milliseconds");
365: args.nargs = 0;
366: args.nreturns = 1;
367: openfirmware(&args);
368: return args.ms;
369: }
370:
371: void
372: OF_chain(virt, size, entry, arg, len)
373: void *virt;
374: u_int size;
375: void (*entry)();
376: void *arg;
377: u_int len;
378: {
379: extern int64_t romp;
380: extern int debug;
381: struct {
382: cell_t name;
383: cell_t nargs;
384: cell_t nreturns;
385: cell_t virt;
386: cell_t size;
387: cell_t entry;
388: cell_t arg;
389: cell_t len;
390: } args;
391:
392: args.name = ADR2CELL("chain");
393: args.nargs = 5;
394: args.nreturns = 0;
395: args.virt = ADR2CELL(virt);
396: args.size = size;
397: args.entry = ADR2CELL(entry);
398: args.arg = ADR2CELL(arg);
399: args.len = len;
400: openfirmware(&args);
401: if (debug) {
402: printf("OF_chain: prom returned!\n");
403:
404: /* OK, firmware failed us. Try calling prog directly */
405: printf("Calling entry(0, %p, %x, %lx, %lx)\n", arg, len,
406: (unsigned long)romp, (unsigned long)romp);
407: }
408: entry(0, arg, len, (unsigned long)romp, (unsigned long)romp);
409: panic("OF_chain: kernel returned!");
410: __asm("ta 2" : :);
411: }
412:
413: static u_int stdin;
414: static u_int stdout;
415: static u_int mmuh = -1;
416: static u_int memh = -1;
417:
418: void
419: setup()
420: {
421: u_int chosen;
422:
423: if ((chosen = OF_finddevice("/chosen")) == -1)
424: _rtt();
425: if (OF_getprop(chosen, "stdin", &stdin, sizeof(stdin)) != sizeof(stdin)
426: || OF_getprop(chosen, "stdout", &stdout, sizeof(stdout)) != sizeof(stdout)
427: || OF_getprop(chosen, "mmu", &mmuh, sizeof(mmuh)) != sizeof(mmuh)
428: || OF_getprop(chosen, "memory", &memh, sizeof(memh)) != sizeof(memh))
429: _rtt();
430: }
431:
432: /*
433: * The following need either the handle to memory or the handle to the MMU.
434: */
435:
436: /*
437: * Grab some address space from the prom
438: *
439: * Only works while the prom is actively mapping us.
440: */
441: static vaddr_t
442: OF_claim_virt(vaddr, len)
443: vaddr_t vaddr;
444: int len;
445: {
446: struct {
447: cell_t name;
448: cell_t nargs;
449: cell_t nreturns;
450: cell_t method;
451: cell_t ihandle;
452: cell_t align;
453: cell_t len;
454: cell_t vaddr;
455: cell_t status;
456: cell_t retaddr;
457: } args;
458:
459: #ifdef __notyet
460: if (mmuh == -1 && ((mmuh = get_mmu_handle()) == -1)) {
461: printf("OF_claim_virt: cannot get mmuh\r\n");
462: return -1LL;
463: }
464: #endif
465: args.name = ADR2CELL("call-method");
466: args.nargs = 5;
467: args.nreturns = 2;
468: args.method = ADR2CELL("claim");
469: args.ihandle = HDL2CELL(mmuh);
470: args.align = 0;
471: args.len = len;
472: args.vaddr = ADR2CELL(vaddr);
473: if (openfirmware(&args) != 0)
474: return -1LL;
475: return (vaddr_t)args.retaddr;
476: }
477:
478: /*
479: * Request some address space from the prom
480: *
481: * Only works while the prom is actively mapping us.
482: */
483: static vaddr_t
484: OF_alloc_virt(len, align)
485: int len;
486: int align;
487: {
488: int retaddr=-1;
489: struct {
490: cell_t name;
491: cell_t nargs;
492: cell_t nreturns;
493: cell_t method;
494: cell_t ihandle;
495: cell_t align;
496: cell_t len;
497: cell_t status;
498: cell_t retaddr;
499: } args;
500:
501: #ifdef __notyet
502: if (mmuh == -1 && ((mmuh = get_mmu_handle()) == -1)) {
503: printf("OF_alloc_virt: cannot get mmuh\r\n");
504: return -1LL;
505: }
506: #endif
507: args.name = ADR2CELL("call-method");
508: args.nargs = 4;
509: args.nreturns = 2;
510: args.method = ADR2CELL("claim");
511: args.ihandle = HDL2CELL(mmuh);
512: args.align = align;
513: args.len = len;
514: args.retaddr = ADR2CELL(&retaddr);
515: if (openfirmware(&args) != 0)
516: return -1LL;
517: return (vaddr_t)args.retaddr;
518: }
519:
520: /*
521: * Release some address space to the prom
522: *
523: * Only works while the prom is actively mapping us.
524: */
525: static int
526: OF_free_virt(vaddr, len)
527: vaddr_t vaddr;
528: int len;
529: {
530: struct {
531: cell_t name;
532: cell_t nargs;
533: cell_t nreturns;
534: cell_t method;
535: cell_t ihandle;
536: cell_t len;
537: cell_t vaddr;
538: } args;
539:
540: #ifdef __notyet
541: if (mmuh == -1 && ((mmuh = get_mmu_handle()) == -1)) {
542: printf("OF_free_virt: cannot get mmuh\r\n");
543: return -1;
544: }
545: #endif
546: args.name = ADR2CELL("call-method");
547: args.nargs = 4;
548: args.nreturns = 0;
549: args.method = ADR2CELL("release");
550: args.ihandle = HDL2CELL(mmuh);
551: args.vaddr = ADR2CELL(vaddr);
552: args.len = len;
553: return openfirmware(&args);
554: }
555:
556:
557: /*
558: * Have prom map in some memory
559: *
560: * Only works while the prom is actively mapping us.
561: */
562: static vaddr_t
563: OF_map_phys(paddr, size, vaddr, mode)
564: paddr_t paddr;
565: off_t size;
566: vaddr_t vaddr;
567: int mode;
568: {
569: struct {
570: cell_t name;
571: cell_t nargs;
572: cell_t nreturns;
573: cell_t method;
574: cell_t ihandle;
575: cell_t mode;
576: cell_t size;
577: cell_t vaddr;
578: cell_t paddr_hi;
579: cell_t paddr_lo;
580: cell_t status;
581: cell_t retaddr;
582: } args;
583:
584: #ifdef __notyet
585: if (mmuh == -1 && ((mmuh = get_mmu_handle()) == -1)) {
586: printf("OF_map_phys: cannot get mmuh\r\n");
587: return 0LL;
588: }
589: #endif
590: args.name = ADR2CELL("call-method");
591: args.nargs = 7;
592: args.nreturns = 1;
593: args.method = ADR2CELL("map");
594: args.ihandle = HDL2CELL(mmuh);
595: args.mode = mode;
596: args.size = size;
597: args.vaddr = ADR2CELL(vaddr);
598: args.paddr_hi = HDQ2CELL_HI(paddr);
599: args.paddr_lo = HDQ2CELL_LO(paddr);
600:
601: if (openfirmware(&args) == -1)
602: return -1;
603: if (args.status)
604: return -1;
605: return (vaddr_t)args.retaddr;
606: }
607:
608:
609: /*
610: * Request some RAM from the prom
611: *
612: * Only works while the prom is actively mapping us.
613: */
614: static paddr_t
615: OF_alloc_phys(len, align)
616: int len;
617: int align;
618: {
619: struct {
620: cell_t name;
621: cell_t nargs;
622: cell_t nreturns;
623: cell_t method;
624: cell_t ihandle;
625: cell_t align;
626: cell_t len;
627: cell_t status;
628: cell_t phys_hi;
629: cell_t phys_lo;
630: } args;
631:
632: #ifdef __notyet
633: if (memh == -1 && ((memh = get_memory_handle()) == -1)) {
634: printf("OF_alloc_phys: cannot get memh\r\n");
635: return -1LL;
636: }
637: #endif
638: args.name = ADR2CELL("call-method");
639: args.nargs = 4;
640: args.nreturns = 3;
641: args.method = ADR2CELL("claim");
642: args.ihandle = HDL2CELL(memh);
643: args.align = align;
644: args.len = len;
645: if (openfirmware(&args) != 0)
646: return -1LL;
647: return (paddr_t)CELL2HDQ(args.phys_hi, args.phys_lo);
648: }
649:
650:
651: /*
652: * Free some RAM to prom
653: *
654: * Only works while the prom is actively mapping us.
655: */
656: static int
657: OF_free_phys(phys, len)
658: paddr_t phys;
659: int len;
660: {
661: struct {
662: cell_t name;
663: cell_t nargs;
664: cell_t nreturns;
665: cell_t method;
666: cell_t ihandle;
667: cell_t len;
668: cell_t phys_hi;
669: cell_t phys_lo;
670: } args;
671:
672: #ifdef __notyet
673: if (memh == -1 && ((memh = get_memory_handle()) == -1)) {
674: printf("OF_free_phys: cannot get memh\r\n");
675: return -1;
676: }
677: #endif
678: args.name = ADR2CELL("call-method");
679: args.nargs = 5;
680: args.nreturns = 0;
681: args.method = ADR2CELL("release");
682: args.ihandle = HDL2CELL(memh);
683: args.len = len;
684: args.phys_hi = HDQ2CELL_HI(phys);
685: args.phys_lo = HDQ2CELL_LO(phys);
686: return openfirmware(&args);
687: }
688:
689:
690: /*
691: * Claim virtual memory -- does not map it in.
692: */
693:
694: void *
695: OF_claim(virt, size, align)
696: void *virt;
697: u_int size;
698: u_int align;
699: {
700: #define SUNVMOF
701: #ifndef SUNVMOF
702: struct {
703: cell_t name;
704: cell_t nargs;
705: cell_t nreturns;
706: cell_t virt;
707: cell_t size;
708: cell_t align;
709: cell_t baseaddr;
710: } args;
711:
712:
713: args.name = ADR2CELL("claim");
714: args.nargs = 3;
715: args.nreturns = 1;
716: args.virt = virt;
717: args.size = size;
718: args.align = align;
719: if (openfirmware(&args) == -1)
720: return (void *)-1;
721: return (void *)args.baseaddr;
722: #else
723: /*
724: * Sun Ultra machines run the firmware with VM enabled,
725: * so you need to handle allocating and mapping both
726: * virtual and physical memory. Ugh.
727: */
728:
729: paddr_t paddr;
730: void * newvirt = NULL;
731:
732: if (virt == NULL) {
733: virt = (void *)OF_alloc_virt(size, align);
734: if (virt == (void *)-1LL) {
735: printf("OF_alloc_virt(%d,%d) failed w/%x\n",
736: size, align, virt);
737: return virt;
738: }
739: } else {
740: newvirt = (void *)OF_claim_virt((vaddr_t)virt, size);
741: if (newvirt == (void *)-1LL) {
742: printf("OF_claim_virt(%x,%d) failed w/%x\n",
743: virt, size, newvirt);
744: return newvirt;
745: }
746: virt = newvirt;
747: }
748: if ((paddr = OF_alloc_phys(size, align)) == (paddr_t)-1LL) {
749: printf("OF_alloc_phys(%d,%d) failed\n", size, align);
750: OF_free_virt((vaddr_t)virt, size);
751: return (void *)-1LL;
752: }
753: if (OF_map_phys(paddr, size, (vaddr_t)virt, -1) == -1) {
754: printf("OF_map_phys(%x,%d,%x,%d) failed\n",
755: paddr, size, virt, -1);
756: OF_free_phys((paddr_t)paddr, size);
757: OF_free_virt((vaddr_t)virt, size);
758: return (void *)-1LL;
759: }
760: return virt;
761: #endif
762: }
763:
764:
765: void
766: putchar(c)
767: int c;
768: {
769: char ch = c;
770:
771: if (c == '\n')
772: putchar('\r');
773: OF_write(stdout, &ch, 1);
774: }
775:
776: int
777: getchar()
778: {
779: unsigned char ch = '\0';
780: int l;
781:
782: while ((l = OF_read(stdin, &ch, 1)) != 1)
783: if (l != -2 && l != 0)
784: return -1;
785: return ch;
786: }