Cosmetic cleanups.
[dragonfly.git] / sys / boot / alpha / boot1 / boot1.c
1 /*
2  * From $NetBSD: bootxx.c,v 1.4 1997/09/06 14:08:29 drochner Exp $ 
3  * $FreeBSD$
4  * $DragonFly: src/sys/boot/alpha/boot1/Attic/boot1.c,v 1.4 2003/11/10 06:08:25 dillon Exp $
5  */
6
7 /*
8  * Copyright (c) 1995 Carnegie-Mellon University.
9  * All rights reserved.
10  *
11  * Author: Chris G. Demetriou
12  *
13  * Permission to use, copy, modify and distribute this software and
14  * its documentation is hereby granted, provided that both the copyright
15  * notice and this permission notice appear in all copies of the
16  * software, derivative works or modified versions, and any portions
17  * thereof, and that both notices appear in supporting documentation.
18  *
19  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
20  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
21  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
22  *
23  * Carnegie Mellon requests users of this software to return to
24  *
25  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
26  *  School of Computer Science
27  *  Carnegie Mellon University
28  *  Pittsburgh PA 15213-3890
29  *
30  * any improvements or extensions that they make and grant Carnegie the
31  * rights to redistribute these changes.
32  */
33
34 #include <string.h>
35 #include <sys/param.h>
36 #include <sys/dirent.h>
37
38 #include <machine/prom.h>
39 #include <machine/rpb.h>
40
41 #define DEBUGxx
42
43 void puts(const char *s);
44 void puthex(u_long v);
45 static int dskread(void *, u_int64_t, size_t);
46
47 #define printf(...) \
48 while (0)
49
50 #define memcpy(dst, src, len) \
51 bcopy(src, dst, len)
52
53 #include "ufsread.c"
54
55 extern end[];
56 int errno;
57
58 char *heap = (char*) end;
59
60 void
61 bcopy(const void *src, void *dst, size_t len) 
62 {
63         const char *s;
64         char *d;
65                  
66         for (d = dst, s = src; len; len--)
67                 *d++ = *s++;
68 }
69
70 void
71 putchar(int c)
72 {
73     if (c == '\n')
74         prom_putchar('\r');
75     prom_putchar(c);
76 }
77
78 int
79 getchar()
80 {
81     return prom_getchar();
82 }
83
84 int
85 ischar()
86 {
87     return prom_poll();
88 }
89
90 void
91 puts(const char *s)
92 {
93     while (*s)
94         putchar(*s++);
95 }
96
97 void
98 panic(const char *message, ...)
99 {
100     puts(message);
101     puts("\r\n");
102     halt();
103 }
104
105 int prom_fd = 0;
106
107 int
108 devopen()
109 {
110     prom_return_t ret;
111     char devname[64];
112     
113     if (prom_fd)
114         return;
115
116     ret.bits = prom_getenv(PROM_E_BOOTED_DEV, devname, sizeof devname);
117
118     ret.bits = prom_open(devname, ret.u.retval + 1);
119     if (ret.u.status)
120         panic("devopen: open failed\n");
121
122     prom_fd = ret.u.retval;
123
124     /* XXX read disklabel and setup partition offset */
125
126     return 0;
127 }
128
129 #ifdef DEBUG
130
131 void
132 puthex(u_long v)
133 {
134     int digit;
135     char hex[] = "0123456789abcdef";
136
137     puts("0x");
138     if (!v) {
139         puts("0");
140         return;
141     }
142
143     for (digit = 0; v >= (0x10L << digit); digit += 4)
144         ;
145
146     for (; digit >= 0; digit -= 4)
147         putchar(hex[(v >> digit) & 0xf]);
148 }
149
150 #endif
151
152 int
153 dskread(void *buf, u_int64_t block, size_t size)
154 {
155 #ifdef DEBUG
156     puts("dskread(");
157     puthex((u_long)buf);
158     puts(",");
159     puthex(block);
160     puts(",");
161     puthex(size);
162     puts(")\n");
163 #endif
164
165     prom_read(prom_fd, size * DEV_BSIZE, buf, block);
166     return (0);
167 }
168
169 static inline void
170 devclose()
171 {
172     if (prom_fd) {
173         prom_close(prom_fd);
174         prom_fd = 0;
175     }
176 }
177
178 static inline void
179 getfilename(char *filename, const char *defname)
180 {
181     int c;
182     char *p = filename;
183
184     puts("Boot: ");
185
186     while ((c = getchar()) != '\r') {
187         if (c == '\b' || c == 0177) {
188             if (p > filename) {
189                 puts("\b \b");
190                 p--;
191             }
192         } else {
193             putchar(c);
194             *p++ = c;
195         }
196     }
197     putchar('\n');
198     *p = '\0';
199     if (!*filename)
200         strcpy(filename, defname);
201     return;
202 }
203
204 static struct dmadat __dmadat;
205
206 static inline void
207 loadfile(char *name, char *addr)
208 {
209     int n;
210     char *p;
211     ino_t ino;
212
213     puts("Loading ");
214     puts(name);
215     puts("\n");
216
217     dmadat = &__dmadat;
218
219     if (devopen() || (ino = lookup(name)) == 0) {
220         puts("Can't open file ");
221         puts(name);
222         puts("\n");
223         halt();
224     }
225
226     p = addr;
227     do {
228             n = fsread(ino, p, VBLKSIZE);
229             if (n < 0) {
230                 puts("Can't read file ");
231                 puts(name);
232                 puts("\n");
233                 halt();
234             }
235         p += n;
236         twiddle();
237     } while (n == VBLKSIZE);
238
239     devclose();
240 }
241
242 static inline u_long rpcc()
243 {
244     u_long v;
245     __asm__ __volatile__ ("rpcc %0" : "=r"(v));
246     return v & 0xffffffff;
247 }
248
249 int
250 main()
251 {
252     char *loadaddr = (char*) SECONDARY_LOAD_ADDRESS;
253     char *name = "/boot/loader";
254     char *p;
255     char filename[512];
256     void (*entry)(void);
257     u_long start, freq;
258     int i;
259
260     init_prom_calls();
261
262     start = rpcc();
263     freq = ((struct rpb *)HWRPB_ADDR)->rpb_cc_freq;
264     while (((rpcc() - start) & 0xffffffff) < freq) {
265         twiddle();
266         if (ischar()) {
267             getfilename(filename, name);
268             name = filename;
269             break;
270         }
271     }
272
273     loadfile(name, loadaddr);
274
275     entry = (void (*)())loadaddr;
276     (*entry)();
277
278     return 0;
279 }