?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Test initialisation of MUIA_List_AdjustWidth and MUIA_List_AdjustHeight, and
[AROS.git] / arch / .unmaintained / ppc-native / boot / linuxboot.c
blobfd3c045b438c2904e3797fd06276c356079872ce
1 /*
2 * linux/arch/m68k/boot/amiga/linuxboot.c -- Generic routine to boot Linux/m68k
3 * on Amiga, used by both Amiboot and
4 * Amiga-Lilo.
5 *
6 * Created 1996 by Geert Uytterhoeven
7 *
8 *
9 * This file is based on the original bootstrap code (bootstrap.c):
10 *
11 * Copyright (C) 1993, 1994 Hamish Macdonald
12 * Greg Harp
13 *
14 * with work by Michael Rausch
15 * Geert Uytterhoeven
16 * Frank Neumann
17 * Andreas Schwab
18 * Jesper Skov
19 *
20 *
21 * This file is subject to the terms and conditions of the GNU General Public
22 * License. See the file COPYING in the main directory of this archive
23 * for more details.
24 *
25 * History:
26 * 26 Feb 1998 Added support for booting APUS systems.
27 * 27 Mar 1997 FPU-less machines couldn't boot kernels that use bootinfo
28 * interface version 1.0 (Geert)
29 * 03 Feb 1997 Implemented kernel decompression (Geert, based on Roman's
30 * code for ataboot)
31 * 30 Dec 1996 Reverted the CPU detection to the old scheme
32 * New boot parameter override scheme (Geert)
33 * 27 Nov 1996 Compatibility with bootinfo interface version 1.0 (Geert)
34 * 9 Sep 1996 Rewritten option parsing
35 * New parameter passing to linuxboot() (linuxboot_args)
36 * (Geert)
37 * 18 Aug 1996 Updated for the new boot information structure (Geert)
38 * 10 Jan 1996 The real Linux/m68k boot code moved to linuxboot.[ch]
39 * (Geert)
40 * 11 Jul 1995 Support for ELF kernel (untested!) (Andreas)
41 * 7 Mar 1995 Memory block sizes are rounded to a multiple of 256K
42 * instead of 1M (Geert)
43 * 31 May 1994 Memory thrash problem solved (Geert)
44 * 11 May 1994 A3640 MapROM check (Geert)
45 */
46
47
48 #ifndef __GNUC__
49 #error GNU CC is required to compile this program
50 #endif /* __GNUC__ */
51
52
53 #define BOOTINFO_COMPAT_1_0 /* bootinfo interface version 1.0 compatible */
54 /* support compressed kernels? */
55 #define ZKERNEL
56
57 #include <stddef.h>
58 #include <string.h>
59 #include <errno.h>
60 #include <sys/types.h>
61
62 #include <linux/a.out.h>
63 #include <linux/elf.h>
64 #include <linux/linkage.h>
65 #include <asm/bootinfo.h>
66 #include <asm/amigahw.h>
67 #include <asm/page.h>
68
69 #include "linuxboot.h"
70
71 #define APUS
72 #ifdef APUS
73
74 #define INTUITION_CLASSES_H 1
75
76 #include <powerup/ppclib/interface.h>
77 /*#include <powerup/gcclib/powerup_protos.h>*/
78 #include <powerup/ppclib/message.h>
79 #include <powerup/ppclib/tasks.h>
80 #include <powerup/ppclib/object.h>
81 #include "ppcboot_elf.h"
82
83 #endif
84
85 #undef custom
86 #define custom ((*(volatile struct CUSTOM *)(CUSTOM_PHYSADDR)))
87
88 /* temporary stack size */
89 #define TEMP_STACKSIZE (256)
90
91 #define DEFAULT_BAUD (9600)
92
93 extern char copyall, copyallend;
94
95 extern char getvbr, wedgie;
96
97 static struct exec kexec;
98 static Elf32_Ehdr kexec_elf;
99 static const struct linuxboot_args *linuxboot_args;
100
101 /* Bootinfo */
102 struct amiga_bootinfo bi;
103
104 #ifdef BOOTINFO_COMPAT_1_0
105 static struct compat_bootinfo compat_bootinfo;
106 #endif /* BOOTINFO_COMPAT_1_0 */
107
108 #define MAX_BI_SIZE (4096)
109 static u_long bi_size;
110 static union {
111 struct bi_record record;
112 u_char fake[MAX_BI_SIZE];
113 } bi_union;
114
115 #define kernelname linuxboot_args->kernelname
116 #define ramdiskname linuxboot_args->ramdiskname
117 #define debugflag linuxboot_args->debugflag
118 #define keep_video linuxboot_args->keep_video
119 #define reset_boards linuxboot_args->reset_boards
120 #define baud linuxboot_args->baud
121
122 #define apus_boot linuxboot_args->apus_boot
123 #define checksum linuxboot_args->checksum
124
125 #define Puts linuxboot_args->puts
126 #define GetChar linuxboot_args->getchar
127 #define PutChar linuxboot_args->putchar
128 #define Printf linuxboot_args->printf
129 #define Open linuxboot_args->open
130 #define Seek linuxboot_args->seek
131 #define Read linuxboot_args->read
132 #define Close linuxboot_args->close
133 #define FileSize linuxboot_args->filesize
134 #define Sleep linuxboot_args->sleep
135
136 /*
137 * Function Prototypes
138 */
139
140 static u_long get_chipset(void);
141 static void get_processor(u_long *cpu, u_long *fpu, u_long *mmu);
142 static u_long get_model(u_long chipset);
143 static int probe_resident(const char *name);
144 static int probe_resource(const char *name);
145 static int create_bootinfo(void);
146 #ifdef BOOTINFO_COMPAT_1_0
147 static int create_compat_bootinfo(void);
148 #endif /* BOOTINFO_COMPAT_1_0 */
149 static int add_bi_record(u_short tag, u_short size, const void *data);
150 static int add_bi_string(u_short tag, const u_char *s);
151 static int check_bootinfo_version(const char *memptr);
152 static void start_kernel(void (*startfunc)(), char *stackp, char *memptr,
153 u_long start_mem, u_long mem_size, u_long rd_size,
154 u_long kernel_size) __attribute__ ((noreturn));
155 asmlinkage u_long probe_powerup(u_long);
156 asmlinkage u_long maprommed(void);
157 asmlinkage u_long check346(void);
158 #ifdef ZKERNEL
159 static int load_zkernel(int fd);
160 static int KRead(int fd, void *buf, int cnt);
161 static int KSeek(int fd, int offset);
162 static int KClose(int fd);
163 #else
164 #define KRead Read
165 #define KSeek Seek
166 #define KClose Close
167 #endif
168
169
170 /*
171 * Reset functions for nasty Zorro boards
172 */
173
174 static void reset_rb3(const struct ConfigDev *cd);
175 static void reset_piccolo(const struct ConfigDev *cd);
176 static void reset_sd64(const struct ConfigDev *cd);
177 static void reset_a2065(const struct ConfigDev *cd);
178 static void reset_ariadne(const struct ConfigDev *cd);
179 static void reset_hydra(const struct ConfigDev *cd);
180 #if 0
181 static void reset_a2060(const struct ConfigDev *cd);
182 #endif
183
184 struct boardreset {
185 u_short manuf;
186 u_short prod;
187 const char *name;
188 void (*reset)(const struct ConfigDev *cd);
189 };
190
191 static struct boardreset boardresetdb[] = {
192 { MANUF_HELFRICH1, PROD_RAINBOW3, "Rainbow 3", reset_rb3 },
193 { MANUF_HELFRICH2, PROD_PICCOLO_REG, "Piccolo", reset_piccolo },
194 { MANUF_HELFRICH2, PROD_SD64_REG, "SD64", reset_sd64 },
195 { MANUF_COMMODORE, PROD_A2065, "A2065", reset_a2065 },
196 { MANUF_VILLAGE_TRONIC, PROD_ARIADNE, "Ariadne", reset_ariadne },
197 { MANUF_HYDRA_SYSTEMS, PROD_AMIGANET, "Hydra", reset_hydra },
198 #if 0
199 { MANUF_COMMODORE, PROD_A2060, "A2060", reset_a2060 },
200 #endif
201 };
202 #define NUM_BOARDRESET sizeof(boardresetdb)/sizeof(*boardresetdb)
203
204 static void (*boardresetfuncs[ZORRO_NUM_AUTO])(const struct ConfigDev *cd);
205
206
207 const char *amiga_models[] = {
208 "Amiga 500", "Amiga 500+", "Amiga 600", "Amiga 1000", "Amiga 1200",
209 "Amiga 2000", "Amiga 2500", "Amiga 3000", "Amiga 3000T", "Amiga 3000+",
210 "Amiga 4000", "Amiga 4000T", "CDTV", "CD32", "Draco"
211 };
212 const u_long first_amiga_model = AMI_500;
213 const u_long last_amiga_model = AMI_DRACO;
214
215
216 #define MASK(model) (1<<AMI_##model)
217
218 #define CLASS_A3000 (MASK(3000) | MASK(3000T))
219 #define CLASS_A4000 (MASK(4000) | MASK(4000T))
220 #define CLASS_ZKICK (MASK(500) | MASK(1000) | MASK(2000) | MASK(2500))
221
222
223 /*
224 * Boot the Linux/m68k Operating System
225 */
226
227 u_long linuxboot(const struct linuxboot_args *args)
228 {
229 int kfd = -1, rfd = -1, elf_kernel = 0, do_fast, do_chip;
230 int i, j;
231 const struct MemHeader *mnp;
232 struct ConfigDev *cdp = NULL;
233 char *memptr = NULL;
234 u_long *stack = NULL;
235 u_long fast_total, model_mask, startcodesize, start_mem, mem_size, rd_size;
236 u_long kernel_size;
237 u_int realbaud;
238 u_long memreq = 0, text_offset = 0;
239 Elf32_Phdr *kernel_phdrs = NULL;
240 void (*startfunc)(void);
241 u_short manuf;
242 u_char prod;
243 void *bi_ptr;
244 unsigned long* info;
245 struct ConfigDev *zdevs[ZORRO_NUM_AUTO];
246
247 linuxboot_args = args;
248
249 /* print the greet message */
250 Puts("\nLinux/m68k Amiga Bootstrap version " AMIBOOT_VERSION "\n");
251 Puts("Copyright 1993,1994 by Hamish Macdonald and Greg Harp\n\n");
252
253 /* Note: Initial values in bi override detected values */
254 bi = args->bi;
255
256 /* machine is Amiga */
257 bi.machtype = MACH_AMIGA;
258
259 /* determine chipset */
260 if (!bi.chipset)
261 bi.chipset = get_chipset();
262
263 /* determine CPU, FPU and MMU type */
264 if (!bi.cputype)
265 get_processor(&bi.cputype, &bi.fputype, &bi.mmutype);
266
267 /* determine Amiga model */
268 if (!bi.model)
269 bi.model = get_model(bi.chipset);
270 model_mask = (bi.model != AMI_UNKNOWN) ? 1<<bi.model : 0;
271
272 /* Memory & AutoConfig based on 'unix_boot.c' by C= */
273
274 /* find all of the autoconfig boards in the system */
275 if (!bi.num_autocon)
276 for (i = 0; (cdp = (struct ConfigDev *)FindConfigDev(cdp, -1, -1)); i++)
277 if (bi.num_autocon < ZORRO_NUM_AUTO) {
278 zdevs[i] = cdp;
279 /* copy the contents of each structure into our boot info and
280 count this device */
281 memcpy(&bi.autocon[bi.num_autocon++], cdp,
282 sizeof(struct ConfigDev));
283 } else
284 Printf("Warning: too many AutoConfig devices. Ignoring device "
285 "at 0x%08lx\n", cdp->cd_BoardAddr);
286
287 do_fast = bi.num_memory ? 0 : 1;
288 do_chip = bi.chip_size ? 0 : 1;
289 /* find out the memory in the system */
290 for (mnp = (struct MemHeader *)SysBase->MemList.lh_Head;
291 mnp->mh_Node.ln_Succ;
292 mnp = (struct MemHeader *)mnp->mh_Node.ln_Succ) {
293 struct MemHeader mh;
294
295 /* copy the information */
296 mh = *mnp;
297
298 /* skip virtual memory */
299 if (!(mh.mh_Attributes & MEMF_PUBLIC))
300 continue;
301
302 /* if we suspect that Kickstart is shadowed in an A3000,
303 modify the entry to show 512K more at the top of RAM
304 Check first for a MapROMmed A3640 board: overwriting the
305 Kickstart image causes an infinite lock-up on reboot! */
306 if ((mh.mh_Upper == (void *)0x07f80000) &&
307 (model_mask & (CLASS_A3000 | CLASS_A4000)))
308 if ((bi.cputype & CPU_68040) && Supervisor(maprommed))
309 Puts("A3640 MapROM detected.\n");
310 else if (model_mask & CLASS_A3000) {
311 mh.mh_Upper = (void *)0x08000000;
312 Puts("A3000 shadowed Kickstart detected.\n");
313 }
314
315 /* if we suspect that Kickstart is zkicked,
316 modify the entry to show 512K more at the botton of RAM */
317 if ((mh.mh_Lower == (void *)0x00280020) &&
318 (model_mask & CLASS_ZKICK)) {
319 mh.mh_Lower = (void *)0x00200000;
320 Puts("ZKick detected.\n");
321 }
322
323 /* mask the memory limit values */
324 mh.mh_Upper = (void *)((u_long)mh.mh_Upper & 0xfffff000);
325 mh.mh_Lower = (void *)((u_long)mh.mh_Lower & 0xfffff000);
326
327 /* if fast memory */
328 if (do_fast && mh.mh_Attributes & MEMF_FAST) {
329 /* set the size value to the size of this block and mask off to a
330 256K increment */
331 u_long size = ((u_long)mh.mh_Upper-(u_long)mh.mh_Lower)&0xfffc0000;
332 if (size > 0)
333 if (bi.num_memory < NUM_MEMINFO) {
334 /* record the start and size */
335 bi.memory[bi.num_memory].addr = (u_long)mh.mh_Lower;
336 bi.memory[bi.num_memory].size = size;
337 /* count this block */
338 bi.num_memory++;
339 } else
340 Printf("Warning: too many memory blocks. Ignoring block "
341 "of %ldK at 0x%08x\n", size>>10,
342 (u_long)mh.mh_Lower);
343 } else if (do_chip && mh.mh_Attributes & MEMF_CHIP)
344 /* if CHIP memory, record the size */
345 bi.chip_size = (u_long)mh.mh_Upper;
346 }
347
348 /* get info from ExecBase */
349 if (!bi.vblank)
350 bi.vblank = SysBase->VBlankFrequency;
351 if (!bi.psfreq)
352 bi.psfreq = SysBase->PowerSupplyFrequency;
353 if (!bi.eclock)
354 bi.eclock = SysBase->ex_EClockFrequency;
355
356 /* serial port */
357 if (!bi.serper) {
358 realbaud = baud ? baud : DEFAULT_BAUD;
359 bi.serper = (5*bi.eclock+realbaud/2)/realbaud-1;
360 }
361
362 /* display Amiga model */
363 if (bi.model >= first_amiga_model && bi.model <= last_amiga_model)
364 Printf("%s ", amiga_models[bi.model-first_amiga_model]);
365 else
366 Puts("Amiga ");
367
368 /* display the CPU type */
369 Puts("CPU: ");
370 switch (bi.cputype) {
371 case CPU_68020:
372 Puts("68020 (Do you have an MMU?)");
373 break;
374 case CPU_68030:
375 Puts("68030");
376 break;
377 case CPU_68040:
378 Puts("68040");
379 break;
380 case CPU_68060:
381 Puts("68060");
382 break;
383 default:
384 Puts("Insufficient for Linux. Aborting...\n");
385 Printf("SysBase->AttnFlags = 0x%08lx\n", SysBase->AttnFlags);
386 goto Fail;
387 }
388 switch (bi.fputype) {
389 case FPU_68881:
390 Puts(" with 68881 FPU");
391 break;
392 case FPU_68882:
393 Puts(" with 68882 FPU");
394 break;
395 case FPU_68040:
396 case FPU_68060:
397 Puts(" with internal FPU");
398 break;
399 default:
400 Puts(" without FPU");
401 break;
402 }
403
404 /* display the chipset */
405 switch (bi.chipset) {
406 case CS_STONEAGE:
407 Puts(", old or unknown chipset");
408 break;
409 case CS_OCS:
410 Puts(", OCS");
411 break;
412 case CS_ECS:
413 Puts(", ECS");
414 break;
415 case CS_AGA:
416 Puts(", AGA chipset");
417 break;
418 }
419
420 /* Look for PowerUp PCI bridge. Signal result to kernel in model type.
421 * Not pretty, but it'll do for now.
422 */
423 if (apus_boot) {
424 unsigned long vbr;
425
426 Puts("\n\n");
427 vbr = (unsigned long) Supervisor((void*)&getvbr);
428 if (probe_powerup(vbr)) {
429 Puts("APUS: PCI Bridge detected.");
430 bi.model += 0x100;
431 } else {
432 Puts("APUS: No PCI Bridge detected.");
433 }
434 }
435
436 Puts("\n\n");
437
438 /* display the command line */
439 Printf("Command line is '%s'\n", bi.command_line);
440
441 /* display the clock statistics */
442 Printf("Vertical Blank Frequency: %ldHz\n", bi.vblank);
443 Printf("Power Supply Frequency: %ldHz\n", bi.psfreq);
444 Printf("EClock Frequency: %ldHz\n\n", bi.eclock);
445
446 /* display autoconfig devices */
447 if (bi.num_autocon) {
448 Printf("Found %ld AutoConfig Device%s\n", bi.num_autocon,
449 bi.num_autocon > 1 ? "s" : "");
450 for (i = 0; i < bi.num_autocon; i++) {
451 Printf("Device %ld: addr = 0x%08lx", i,
452 (u_long)zdevs[i]->cd_BoardAddr);
453 boardresetfuncs[i] = NULL;
454 if (reset_boards) {
455 manuf = zdevs[i]->cd_Rom.er_Manufacturer;
456 prod = zdevs[i]->cd_Rom.er_Product;
457 for (j = 0; j < NUM_BOARDRESET; j++)
458 if ((manuf == boardresetdb[j].manuf) &&
459 (prod == boardresetdb[j].prod)) {
460 Printf(" [%s - will be reset at kernel boot time]",
461 boardresetdb[j].name);
462 boardresetfuncs[i] = boardresetdb[j].reset;
463 break;
464 }
465 }
466 PutChar('\n');
467 }
468 } else
469 Puts("No AutoConfig Devices Found\n");
470
471 /* display memory */
472 if (bi.num_memory) {
473 Printf("\nFound %ld Block%sof Memory\n", bi.num_memory,
474 bi.num_memory > 1 ? "s " : " ");
475 for (i = 0; i < bi.num_memory; i++)
476 Printf("Block %ld: 0x%08lx to 0x%08lx (%ldK)\n", i,
477 bi.memory[i].addr, bi.memory[i].addr+bi.memory[i].size,
478 bi.memory[i].size>>10);
479 } else {
480 Puts("No memory found?! Aborting...\n");
481 goto Fail;
482 }
483
484 /* display chip memory size */
485 Printf("%ldK of CHIP memory\n", bi.chip_size>>10);
486
487 start_mem = bi.memory[0].addr;
488 mem_size = bi.memory[0].size;
489
490 /* tell us where the kernel will go */
491 Printf("\nThe kernel will be located at 0x%08lx\n", start_mem);
492
493 /* verify that there is enough Chip RAM */
494 if (bi.chip_size < 512*1024) {
495 Puts("Not enough Chip RAM in this system. Aborting...\n");
496 goto Fail;
497 }
498
499 /* verify that there is enough Fast RAM */
500 for (fast_total = 0, i = 0; i < bi.num_memory; i++)
501 fast_total += bi.memory[i].size;
502 if (fast_total < 2*1024*1024) {
503 Puts("Not enough Fast RAM in this system. Aborting...\n");
504 goto Fail;
505 }
506
507 /* support for ramdisk */
508 if (ramdiskname) {
509 int size;
510
511 if ((size = FileSize(ramdiskname)) == -1) {
512 Printf("Unable to find size of ramdisk file `%s'\n", ramdiskname);
513 goto Fail;
514 }
515 /* record ramdisk size */
516 bi.ramdisk.size = size;
517 } else
518 bi.ramdisk.size = 0;
519 rd_size = bi.ramdisk.size;
520 bi.ramdisk.addr = (u_long)start_mem+mem_size-rd_size;
521
522 /* create the bootinfo structure */
523 if (!create_bootinfo())
524 goto Fail;
525
526 /* open kernel executable and read exec header */
527 if ((kfd = Open(kernelname)) == -1) {
528 Printf("Unable to open kernel file `%s'\n", kernelname);
529 goto Fail;
530 }
531 if (KRead(kfd, (void *)&kexec, sizeof(kexec)) != sizeof(kexec)) {
532 Puts("Unable to read exec header from kernel file\n");
533 goto Fail;
534 }
535
536 #ifdef ZKERNEL
537 if (((unsigned char *)&kexec)[0] == 037 &&
538 (((unsigned char *)&kexec)[1] == 0213 ||
539 ((unsigned char *)&kexec)[1] == 0236)) {
540 /* That's a compressed kernel */
541 Puts("Kernel is compressed\n");
542 if (load_zkernel(kfd)) {
543 Puts("Decompression error -- aborting\n");
544 goto Fail;
545 }
546 }
547 #endif
548
549 switch (N_MAGIC(kexec)) {
550 case ZMAGIC:
551 if (debugflag)
552 Puts("\nLoading a.out (ZMAGIC) Linux/m68k kernel...\n");
553 text_offset = N_TXTOFF(kexec);
554 break;
555
556 case QMAGIC:
557 if (debugflag)
558 Puts("\nLoading a.out (QMAGIC) Linux/m68k kernel...\n");
559 text_offset = sizeof(kexec);
560 /* the text size includes the exec header; remove this */
561 kexec.a_text -= sizeof(kexec);
562 break;
563
564 default:
565 /* Try to parse it as an ELF header */
566 KSeek(kfd, 0);
567 if ((KRead(kfd, (void *)&kexec_elf, sizeof(kexec_elf)) ==
568 sizeof(kexec_elf)) &&
569 (memcmp(&kexec_elf.e_ident[EI_MAG0], ELFMAG, SELFMAG) == 0)) {
570 elf_kernel = 1;
571 if (debugflag)
572 Puts("\nLoading ELF Linux/m68k kernel...\n");
573 /* A few plausibility checks */
574 if ((kexec_elf.e_type != ET_EXEC) ||
575 (kexec_elf.e_machine != EM_PPC && apus_boot) ||
576 (kexec_elf.e_machine != EM_68K && !apus_boot) ||
577 (kexec_elf.e_version != EV_CURRENT)) {
578 Puts("Invalid ELF header contents in kernel\n");
579 Printf("machine : %d, type: %d, version: %d\n",
580 kexec_elf.e_machine, kexec_elf.e_type, kexec_elf.e_version);
581 goto Fail;
582 }
583 /* Load the program headers */
584 if (!(kernel_phdrs =
585 (Elf32_Phdr *)AllocMem(kexec_elf.e_phnum*sizeof(Elf32_Phdr),
586 MEMF_FAST | MEMF_PUBLIC |
587 MEMF_CLEAR))) {
588 Puts("Unable to allocate memory for program headers\n");
589 goto Fail;
590 }
591 KSeek(kfd, kexec_elf.e_phoff);
592 if (KRead(kfd, (void *)kernel_phdrs,
593 kexec_elf.e_phnum*sizeof(*kernel_phdrs)) !=
594 kexec_elf.e_phnum*sizeof(*kernel_phdrs)) {
595 Puts("Unable to read program headers from kernel file\n");
596 goto Fail;
597 }
598 break;
599 }
600 Printf("Wrong magic number 0x%08lx in kernel header\n",
601 N_MAGIC(kexec));
602 goto Fail;
603 }
604
605 /* Load the kernel at one page after start of mem */
606 if (!apus_boot) {
607 start_mem += PAGE_SIZE;
608 mem_size -= PAGE_SIZE;
609 }
610
611 /* Align bss size to multiple of four */
612 if (!elf_kernel)
613 kexec.a_bss = (kexec.a_bss+3) & ~3;
614
615 /* calculate the total required amount of memory */
616 if (elf_kernel) {
617 u_long min_addr = 0xffffffff, max_addr = 0;
618 for (i = 0; i < kexec_elf.e_phnum; i++) {
619 if (min_addr > kernel_phdrs[i].p_vaddr)
620 min_addr = kernel_phdrs[i].p_vaddr;
621 if (max_addr < kernel_phdrs[i].p_vaddr+kernel_phdrs[i].p_memsz)
622 max_addr = kernel_phdrs[i].p_vaddr+kernel_phdrs[i].p_memsz;
623 }
624 /* This is needed for newer linkers that include the header in
625 the first segment. */
626 if (apus_boot) {
627 /* Avoid ugly hacks further down. */
628 kernel_phdrs[0].p_vaddr = PAGE_SIZE;
629 } else if (min_addr == 0) {
630 min_addr = PAGE_SIZE;
631 kernel_phdrs[0].p_vaddr += PAGE_SIZE;
632 kernel_phdrs[0].p_offset += PAGE_SIZE;
633 kernel_phdrs[0].p_filesz -= PAGE_SIZE;
634 kernel_phdrs[0].p_memsz -= PAGE_SIZE;
635 }
636 kernel_size = max_addr-min_addr;
637 } else
638 kernel_size = kexec.a_text+kexec.a_data+kexec.a_bss;
639 memreq = kernel_size+bi_size+rd_size;
640 #ifdef BOOTINFO_COMPAT_1_0
641 if (sizeof(compat_bootinfo) > bi_size)
642 memreq = kernel_size+sizeof(compat_bootinfo)+rd_size;
643 #endif /* BOOTINFO_COMPAT_1_0 */
644 if (!(memptr = (char *)AllocMem(memreq, MEMF_FAST | MEMF_PUBLIC |
645 MEMF_CLEAR))) {
646 Puts("Unable to allocate memory\n");
647 goto Fail;
648 }
649
650 /* read the text and data segments from the kernel image */
651 if (elf_kernel)
652 for (i = 0; i < kexec_elf.e_phnum; i++) {
653 if (KSeek(kfd, kernel_phdrs[i].p_offset) == -1) {
654 Printf("Failed to seek to segment %ld\n", i);
655 goto Fail;
656 }
657 if (KRead(kfd, memptr+kernel_phdrs[i].p_vaddr-PAGE_SIZE,
658 kernel_phdrs[i].p_filesz) != kernel_phdrs[i].p_filesz) {
659 Printf("Failed to read segment %ld\n", i);
660 goto Fail;
661 }
662 }
663 else {
664 if (KSeek(kfd, text_offset) == -1) {
665 Puts("Failed to seek to text\n");
666 goto Fail;
667 }
668 if (KRead(kfd, memptr, kexec.a_text) != kexec.a_text) {
669 Puts("Failed to read text\n");
670 goto Fail;
671 }
672 /* data follows immediately after text */
673 if (KRead(kfd, memptr+kexec.a_text, kexec.a_data) != kexec.a_data) {
674 Puts("Failed to read data\n");
675 goto Fail;
676 }
677 }
678 KClose(kfd);
679 kfd = -1;
680
681 /* Check kernel's bootinfo version */
682 switch (apus_boot ? BI_VERSION_MAJOR(AMIGA_BOOTI_VERSION) :
683 check_bootinfo_version(memptr)) {
684 case BI_VERSION_MAJOR(AMIGA_BOOTI_VERSION):
685 bi_ptr = &bi_union.record;
686 break;
687
688 #ifdef BOOTINFO_COMPAT_1_0
689 case BI_VERSION_MAJOR(COMPAT_AMIGA_BOOTI_VERSION):
690 if (!create_compat_bootinfo())
691 goto Fail;
692 bi_ptr = &compat_bootinfo;
693 bi_size = sizeof(compat_bootinfo);
694 break;
695 #endif /* BOOTINFO_COMPAT_1_0 */
696
697 default:
698 goto Fail;
699 }
700
701 /* copy the bootinfo to the end of the kernel image */
702 memcpy((void *)(memptr+kernel_size), bi_ptr, bi_size);
703
704 if (ramdiskname) {
705 if ((rfd = Open(ramdiskname)) == -1) {
706 Printf("Unable to open ramdisk file `%s'\n", ramdiskname);
707 goto Fail;
708 }
709 if (Read(rfd, memptr+kernel_size+bi_size, rd_size) != rd_size) {
710 Puts("Failed to read ramdisk file\n");
711 goto Fail;
712 }
713 Close(rfd);
714 rfd = -1;
715 }
716
717 /* allocate temporary chip ram stack */
718 if (!(stack = (u_long *)AllocMem(TEMP_STACKSIZE, MEMF_CHIP | MEMF_CLEAR))) {
719 Puts("Unable to allocate memory for stack\n");
720 goto Fail;
721 }
722
723 /* allocate chip ram for copy of startup code */
724 startcodesize = &copyallend-&copyall;
725 if (!(startfunc = (void (*)(void))AllocMem(startcodesize,
726 MEMF_CHIP | MEMF_CLEAR))) {
727 Puts("Unable to allocate memory for startcode\n");
728 goto Fail;
729 }
730
731 /* copy startup code to CHIP RAM */
732 memcpy(startfunc, &copyall, startcodesize);
733
734 if (debugflag) {
735 if (bi.ramdisk.size)
736 Printf("RAM disk at 0x%08lx, size is %ldK\n",
737 (u_long)memptr+kernel_size, bi.ramdisk.size>>10);
738
739 if (elf_kernel) {
740 PutChar('\n');
741 for (i = 0; i < kexec_elf.e_phnum; i++)
742 Printf("Kernel segment %ld at 0x%08lx, size %ld\n", i,
743 start_mem+kernel_phdrs[i].p_vaddr-PAGE_SIZE,
744 kernel_phdrs[i].p_memsz);
745 Printf("Boot info at 0x%08lx\n", start_mem+kernel_size);
746 } else {
747 Printf("\nKernel text at 0x%08lx, code size 0x%08lx\n", start_mem,
748 kexec.a_text);
749 Printf("Kernel data at 0x%08lx, data size 0x%08lx\n",
750 start_mem+kexec.a_text, kexec.a_data);
751 Printf("Kernel bss at 0x%08lx, bss size 0x%08lx\n",
752 start_mem+kexec.a_text+kexec.a_data, kexec.a_bss);
753 Printf("Boot info at 0x%08lx\n", start_mem+kernel_size);
754 }
755 Printf("\nKernel entry is 0x%08lx\n", elf_kernel ? kexec_elf.e_entry :
756 kexec.a_entry);
757
758 Printf("ramdisk dest top is 0x%08lx\n", start_mem+mem_size);
759 Printf("ramdisk lower limit is 0x%08lx\n",
760 (u_long)(memptr+kernel_size));
761 Printf("ramdisk src top is 0x%08lx\n",
762 (u_long)(memptr+kernel_size)+rd_size);
763
764 Puts("\nType a key to continue the Linux/m68k boot...");
765 GetChar();
766 PutChar('\n');
767 }
768
769 /* wait for things to settle down */
770 Sleep(1000000);
771
772
773 {
774 void* PPCPort;
775 void* PPCMsg;
776
777 #define CHIP_PTR (0xfff00)
778 #define INFO_SIZE (0x3000 + 0x0100)
779 if (apus_boot) {
780 /* Let the PowerPC handle the actual kernel start */
781
782 /* Store some relevant information about the kernel image
783 * and RAM disk at *CHIP_PTR.
784 */
785 unsigned long boot_msg;
786
787 /* Make sure the CHIP_PTR will not be destroyed. */
788 if (!AllocAbs (0x10, CHIP_PTR)){
789 Puts("Unable to allocate CHIP memory at 0xfff00.\n"
790 "Try booting with a smaller resolution.\n");
791 }
792
793 if (!(boot_msg = (unsigned long) AllocMem (0x200,
794 MEMF_REVERSE
795 | MEMF_CHIP
796 | MEMF_CLEAR))){
797
798 Puts("Unable to allocate CHIP memory for boot message\n");
799 goto Fail;
800 }
801
802 if (!(info = (unsigned long*) AllocMem (INFO_SIZE,
803 MEMF_CHIP | MEMF_CLEAR))){
804 Puts("Unable to allocate CHIP memory for info table and"
805 " reloc code\n");
806 goto Fail;
807 }
808
809 /* Leave the pointer in chip mem at address CHIP_PTR. */
810 *((unsigned long*) CHIP_PTR) = (unsigned long) info;
811 info[0] = (unsigned long) (memptr+kernel_phdrs[0].p_vaddr-PAGE_SIZE);
812 info[1] = start_mem;
813 info[2] = kernel_size;
814 info[3] = bi_size;
815 info[4] = rd_size;
816 info[5] = mem_size;
817 info[6] = boot_msg + 0x100;
818 info[7] = 0; /* checksum */
819 info[8] = (unsigned long)info + 0x2000; /* stack */
820
821 /* Calculate a simple kernel checksum. */
822 if (checksum)
823 {
824 int i = (info[2] + info[3]) / 4;
825 unsigned char* k_p = (unsigned char*) info[0];
826 unsigned long kcs = 0;
827
828 while (i--)
829 {
830 unsigned long w = 0;
831
832 w |= *k_p++;
833 w <<= 8;
834 w |= *k_p++;
835 w <<= 8;
836 w |= *k_p++;
837 w <<= 8;
838 w |= *k_p++;
839
840
841 kcs = kcs ^ i;
842 kcs = kcs ^ w;
843 }
844 info[7] = kcs;
845 }
846
847 /* Set LVL7 vector ("expose the top rim of our shorts") */
848 {
849 unsigned long* vbr;
850
851 vbr = (unsigned long*) Supervisor((void*)&getvbr);
852 vbr[31] = (unsigned long) &wedgie;
853 }
854
855
856 {
857 void* elfObject;
858 void* task;
859 struct TagItem MyTags[2];
860 struct TagItem tag;
861
862 /* Load PPC elf object. */
863 MyTags[0].ti_Tag = PPCELFLOADTAG_ELFADDRESS;
864 MyTags[0].ti_Data = (u_long)myppc_boot;
865 MyTags[1].ti_Tag = TAG_DONE;
866
867 elfObject = (void*) PPCLoadObjectTagList(MyTags);
868
869 /* Start PPC code, asking for a MSGPORT to be created. */
870 MyTags[0].ti_Tag = PPCTASKTAG_MSGPORT;
871 MyTags[0].ti_Data = TRUE;
872 MyTags[1].ti_Tag = TAG_DONE;
873 task = PPCCreateTask(elfObject, MyTags);
874
875 tag.ti_Tag = PPCTASKINFOTAG_MSGPORT;
876 if (PPCPort=(void*) PPCGetTaskAttrs(task, &tag))
877 {
878 PPCMsg = PPCCreateMessage(NULL, 0);
879 }
880
881
882 if (PPCPort == 0 || PPCMsg == 0)
883 {
884 Puts ("Didn't get contact with PPC task...\n");
885 goto Fail;
886 }
887 }
888 }
889
890 /* turn off caches */
891 CacheControl(0, ~0);
892
893 if (!keep_video)
894 /* set graphics mode to a nice normal one */
895 LoadView(NULL);
896
897 /* reset nasty Zorro boards */
898 if (reset_boards)
899 for (i = 0; i < bi.num_autocon; i++)
900 if (boardresetfuncs[i])
901 boardresetfuncs[i](zdevs[i]);
902
903 if (apus_boot && PPCPort && PPCMsg)
904 {
905 /* Notify the PPC that we are done ("bend over") */
906 PPCSendMessage(PPCPort, PPCMsg, NULL, 0, 0);
907 for (;;) ;
908 }
909
910 /* Go into supervisor state */
911 SuperState();
912
913 }
914 /* Turn off interrupts. */
915 Disable();
916
917 /* Turn off all DMA */
918 custom.dmacon = DMAF_ALL | DMAF_MASTER;
919
920 /* turn off any mmu translation */
921 disable_mmu();
922
923 /* execute the copy-and-go code (from CHIP RAM) */
924 start_kernel(startfunc, (char *)stack+TEMP_STACKSIZE, memptr, start_mem,
925 mem_size, rd_size, kernel_size);
926
927 /* Clean up and exit in case of a failure */
928 Fail:
929 if (kfd != -1)
930 KClose(kfd);
931 if (rfd != -1)
932 Close(rfd);
933 if (info)
934 FreeMem((void *) info, INFO_SIZE);
935 if (memptr)
936 FreeMem((void *)memptr, memreq);
937 if (stack)
938 FreeMem((void *)stack, TEMP_STACKSIZE);
939 if (kernel_phdrs)
940 FreeMem((void *)kernel_phdrs, kexec_elf.e_phnum*sizeof(Elf32_Phdr));
941 return(FALSE);
942 }
943
944
945 /*
946 * Determine the Chipset
947 */
948
949 static u_long get_chipset(void)
950 {
951 u_char cs;
952 u_long chipset;
953
954 if (GfxBase->Version >= 39)
955 cs = SetChipRev(SETCHIPREV_BEST);
956 else
957 cs = GfxBase->ChipRevBits0;
958 if ((cs & GFXG_AGA) == GFXG_AGA)
959 chipset = CS_AGA;
960 else if ((cs & GFXG_ECS) == GFXG_ECS)
961 chipset = CS_ECS;
962 else if ((cs & GFXG_OCS) == GFXG_OCS)
963 chipset = CS_OCS;
964 else
965 chipset = CS_STONEAGE;
966 return(chipset);
967 }
968
969
970 /*
971 * Determine the CPU Type
972 */
973
974 static void get_processor(u_long *cpu, u_long *fpu, u_long *mmu)
975 {
976 *cpu = *fpu = 0;
977
978 if (SysBase->AttnFlags & AFF_68060)
979 *cpu = CPU_68060;
980 else if (SysBase->AttnFlags & AFF_68040)
981 *cpu = CPU_68040;
982 else if (SysBase->AttnFlags & AFF_68030)
983 *cpu = CPU_68030;
984 else if (SysBase->AttnFlags & AFF_68020)
985 *cpu = CPU_68020;
986
987 if (*cpu == CPU_68040 || *cpu == CPU_68060) {
988 if (SysBase->AttnFlags & AFF_FPU40)
989 *fpu = *cpu;
990 } else if (SysBase->AttnFlags & AFF_68882)
991 *fpu = FPU_68882;
992 else if (SysBase->AttnFlags & AFF_68881)
993 *fpu = FPU_68881;
994
995 *mmu = *cpu;
996 }
997
998 /*
999 * Determine the Amiga Model
1000 */
1001
1002 static u_long get_model(u_long chipset)
1003 {
1004 u_long model = AMI_UNKNOWN;
1005
1006 if (debugflag)
1007 Puts("Amiga model identification:\n");
1008 if (probe_resource("draco.resource"))
1009 model = AMI_DRACO;
1010 else {
1011 if (debugflag)
1012 Puts(" Chipset: ");
1013 switch (chipset) {
1014 case CS_STONEAGE:
1015 if (debugflag)
1016 Puts("Old or unknown\n");
1017 goto OCS;
1018 break;
1019
1020 case CS_OCS:
1021 if (debugflag)
1022 Puts("OCS\n");
1023 OCS: if (probe_resident("cd.device"))
1024 model = AMI_CDTV;
1025 else
1026 /* let's call it an A2000 (may be A500, A1000, A2500) */
1027 model = AMI_2000;
1028 break;
1029
1030 case CS_ECS:
1031 if (debugflag)
1032 Puts("ECS\n");
1033 if (probe_resident("Magic 36.7") ||
1034 probe_resident("kickad 36.57") ||
1035 probe_resident("A3000 Bonus") ||
1036 probe_resident("A3000 bonus"))
1037 /* let's call it an A3000 (may be A3000T) */
1038 model = AMI_3000;
1039 else if (probe_resource("card.resource"))
1040 model = AMI_600;
1041 else
1042 /* let's call it an A2000 (may be A500[+], A1000, A2500) */
1043 model = AMI_2000;
1044 break;
1045
1046 case CS_AGA:
1047 if (debugflag)
1048 Puts("AGA\n");
1049 if (probe_resident("A1000 Bonus") ||
1050 probe_resident("A4000 bonus"))
1051 model = probe_resident("NCR scsi.device") ? AMI_4000T :
1052 AMI_4000;
1053 else if (probe_resource("card.resource"))
1054 model = AMI_1200;
1055 else if (probe_resident("cd.device"))
1056 model = AMI_CD32;
1057 else
1058 model = AMI_3000PLUS;
1059 break;
1060 }
1061 }
1062 if (debugflag) {
1063 Puts("\nType a key to continue...");
1064 GetChar();
1065 Puts("\n\n");
1066 }
1067 return(model);
1068 }
1069
1070
1071 /*
1072 * Probe for a Resident Modules
1073 */
1074
1075 static int probe_resident(const char *name)
1076 {
1077 const struct Resident *res;
1078
1079 if (debugflag)
1080 Printf(" Module `%s': ", name);
1081 res = FindResident(name);
1082 if (debugflag)
1083 if (res)
1084 Printf("0x%08lx\n", res);
1085 else
1086 Puts("not present\n");
1087 return(res ? TRUE : FALSE);
1088 }
1089
1090
1091 /*
1092 * Probe for an available Resource
1093 */
1094
1095 static int probe_resource(const char *name)
1096 {
1097 const void *res;
1098
1099 if (debugflag)
1100 Printf(" Resource `%s': ", name);
1101 res = OpenResource(name);
1102 if (debugflag)
1103 if (res)
1104 Printf("0x%08lx\n", res);
1105 else
1106 Puts("not present\n");
1107 return(res ? TRUE : FALSE);
1108 }
1109
1110
1111 /*
1112 * Create the Bootinfo structure
1113 */
1114
1115 static int create_bootinfo(void)
1116 {
1117 int i;
1118 struct bi_record *record;
1119
1120 /* Initialization */
1121 bi_size = 0;
1122
1123 /* Generic tags */
1124 if (!add_bi_record(BI_MACHTYPE, sizeof(bi.machtype), &bi.machtype))
1125 return(0);
1126 if (!add_bi_record(BI_CPUTYPE, sizeof(bi.cputype), &bi.cputype))
1127 return(0);
1128 if (!add_bi_record(BI_FPUTYPE, sizeof(bi.fputype), &bi.fputype))
1129 return(0);
1130 if (!add_bi_record(BI_MMUTYPE, sizeof(bi.mmutype), &bi.mmutype))
1131 return(0);
1132 for (i = 0; i < bi.num_memory; i++)
1133 if (!add_bi_record(BI_MEMCHUNK, sizeof(bi.memory[i]), &bi.memory[i]))
1134 return(0);
1135 if (bi.ramdisk.size)
1136 if (!add_bi_record(BI_RAMDISK, sizeof(bi.ramdisk), &bi.ramdisk))
1137 return(0);
1138 if (!add_bi_string(BI_COMMAND_LINE, bi.command_line))
1139 return(0);
1140
1141 /* Amiga tags */
1142 if (!add_bi_record(BI_AMIGA_MODEL, sizeof(bi.model), &bi.model))
1143 return(0);
1144 for (i = 0; i < bi.num_autocon; i++)
1145 if (!add_bi_record(BI_AMIGA_AUTOCON, sizeof(bi.autocon[i]),
1146 &bi.autocon[i]))
1147 return(0);
1148 if (!add_bi_record(BI_AMIGA_CHIP_SIZE, sizeof(bi.chip_size), &bi.chip_size))
1149 return(0);
1150 if (!add_bi_record(BI_AMIGA_VBLANK, sizeof(bi.vblank), &bi.vblank))
1151 return(0);
1152 if (!add_bi_record(BI_AMIGA_PSFREQ, sizeof(bi.psfreq), &bi.psfreq))
1153 return(0);
1154 if (!add_bi_record(BI_AMIGA_ECLOCK, sizeof(bi.eclock), &bi.eclock))
1155 return(0);
1156 if (!add_bi_record(BI_AMIGA_CHIPSET, sizeof(bi.chipset), &bi.chipset))
1157 return(0);
1158 if (!add_bi_record(BI_AMIGA_SERPER, sizeof(bi.serper), &bi.serper))
1159 return(0);
1160
1161 /* Trailer */
1162 record = (struct bi_record *)((u_long)&bi_union.record+bi_size);
1163 record->tag = BI_LAST;
1164 bi_size += sizeof(bi_union.record.tag);
1165
1166 return(1);
1167 }
1168
1169
1170 /*
1171 * Add a Record to the Bootinfo Structure
1172 */
1173
1174 static int add_bi_record(u_short tag, u_short size, const void *data)
1175 {
1176 struct bi_record *record;
1177 u_int size2;
1178
1179 size2 = (sizeof(struct bi_record)+size+3)&-4;
1180 if (bi_size+size2+sizeof(bi_union.record.tag) > MAX_BI_SIZE) {
1181 Puts("Can't add bootinfo record. Ask a wizard to enlarge me.\n");
1182 return(0);
1183 }
1184 record = (struct bi_record *)((u_long)&bi_union.record+bi_size);
1185 record->tag = tag;
1186 record->size = size2;
1187 memcpy(record->data, data, size);
1188 bi_size += size2;
1189 return(1);
1190 }
1191
1192
1193 /*
1194 * Add a String Record to the Bootinfo Structure
1195 */
1196
1197 static int add_bi_string(u_short tag, const u_char *s)
1198 {
1199 return(add_bi_record(tag, strlen(s)+1, (void *)s));
1200 }
1201
1202
1203 #ifdef BOOTINFO_COMPAT_1_0
1204
1205 /*
1206 * Create the Bootinfo structure for backwards compatibility mode
1207 */
1208
1209 static int create_compat_bootinfo(void)
1210 {
1211 u_int i;
1212
1213 compat_bootinfo.machtype = bi.machtype;
1214 if (bi.cputype & CPU_68020)
1215 compat_bootinfo.cputype = COMPAT_CPU_68020;
1216 else if (bi.cputype & CPU_68030)
1217 compat_bootinfo.cputype = COMPAT_CPU_68030;
1218 else if (bi.cputype & CPU_68040)
1219 compat_bootinfo.cputype = COMPAT_CPU_68040;
1220 else if (bi.cputype & CPU_68060)
1221 compat_bootinfo.cputype = COMPAT_CPU_68060;
1222 else {
1223 Printf("CPU type 0x%08lx not supported by kernel\n", bi.cputype);
1224 return(0);
1225 }
1226 if (bi.fputype & FPU_68881)
1227 compat_bootinfo.cputype |= COMPAT_FPU_68881;
1228 else if (bi.fputype & FPU_68882)
1229 compat_bootinfo.cputype |= COMPAT_FPU_68882;
1230 else if (bi.fputype & FPU_68040)
1231 compat_bootinfo.cputype |= COMPAT_FPU_68040;
1232 else if (bi.fputype & FPU_68060)
1233 compat_bootinfo.cputype |= COMPAT_FPU_68060;
1234 else if (bi.fputype) {
1235 Printf("FPU type 0x%08lx not supported by kernel\n", bi.fputype);
1236 return(0);
1237 }
1238 compat_bootinfo.num_memory = bi.num_memory;
1239 if (compat_bootinfo.num_memory > COMPAT_NUM_MEMINFO) {
1240 Printf("Warning: using only %ld blocks of memory\n",
1241 COMPAT_NUM_MEMINFO);
1242 compat_bootinfo.num_memory = COMPAT_NUM_MEMINFO;
1243 }
1244 for (i = 0; i < compat_bootinfo.num_memory; i++) {
1245 compat_bootinfo.memory[i].addr = bi.memory[i].addr;
1246 compat_bootinfo.memory[i].size = bi.memory[i].size;
1247 }
1248 if (bi.ramdisk.size) {
1249 compat_bootinfo.ramdisk_size = (bi.ramdisk.size+1023)/1024;
1250 compat_bootinfo.ramdisk_addr = bi.ramdisk.addr;
1251 } else {
1252 compat_bootinfo.ramdisk_size = 0;
1253 compat_bootinfo.ramdisk_addr = 0;
1254 }
1255 strncpy(compat_bootinfo.command_line, bi.command_line, COMPAT_CL_SIZE);
1256 compat_bootinfo.command_line[COMPAT_CL_SIZE-1] = '\0';
1257
1258 compat_bootinfo.bi_amiga.model = bi.model;
1259 compat_bootinfo.bi_amiga.num_autocon = bi.num_autocon;
1260 if (compat_bootinfo.bi_amiga.num_autocon > COMPAT_NUM_AUTO) {
1261 Printf("Warning: using only %ld AutoConfig devices\n",
1262 COMPAT_NUM_AUTO);
1263 compat_bootinfo.bi_amiga.num_autocon = COMPAT_NUM_AUTO;
1264 }
1265 for (i = 0; i < compat_bootinfo.bi_amiga.num_autocon; i++)
1266 compat_bootinfo.bi_amiga.autocon[i] = bi.autocon[i];
1267 compat_bootinfo.bi_amiga.chip_size = bi.chip_size;
1268 compat_bootinfo.bi_amiga.vblank = bi.vblank;
1269 compat_bootinfo.bi_amiga.psfreq = bi.psfreq;
1270 compat_bootinfo.bi_amiga.eclock = bi.eclock;
1271 compat_bootinfo.bi_amiga.chipset = bi.chipset;
1272 compat_bootinfo.bi_amiga.hw_present = 0;
1273 return(1);
1274 }
1275 #endif /* BOOTINFO_COMPAT_1_0 */
1276
1277
1278 /*
1279 * Compare the Bootstrap and Kernel Versions
1280 */
1281
1282 static int check_bootinfo_version(const char *memptr)
1283 {
1284 const struct bootversion *bv = (struct bootversion *)memptr;
1285 unsigned long version = 0;
1286 int i, kernel_major, kernel_minor, boots_major, boots_minor;
1287
1288 if (bv->magic == BOOTINFOV_MAGIC)
1289 for (i = 0; bv->machversions[i].machtype != 0; ++i)
1290 if (bv->machversions[i].machtype == MACH_AMIGA) {
1291 version = bv->machversions[i].version;
1292 break;
1293 }
1294 if (!version)
1295 Puts("Kernel has no bootinfo version info, assuming 0.0\n");
1296
1297 kernel_major = BI_VERSION_MAJOR(version);
1298 kernel_minor = BI_VERSION_MINOR(version);
1299 boots_major = BI_VERSION_MAJOR(AMIGA_BOOTI_VERSION);
1300 boots_minor = BI_VERSION_MINOR(AMIGA_BOOTI_VERSION);
1301 Printf("Bootstrap's bootinfo version: %ld.%ld\n", boots_major,
1302 boots_minor);
1303 Printf("Kernel's bootinfo version : %ld.%ld\n", kernel_major,
1304 kernel_minor);
1305
1306 switch (kernel_major) {
1307 case BI_VERSION_MAJOR(AMIGA_BOOTI_VERSION):
1308 if (kernel_minor > boots_minor) {
1309 Puts("Warning: Bootinfo version of bootstrap and kernel "
1310 "differ!\n");
1311 Puts(" Certain features may not work.\n");
1312 }
1313 break;
1314
1315 #ifdef BOOTINFO_COMPAT_1_0
1316 case BI_VERSION_MAJOR(COMPAT_AMIGA_BOOTI_VERSION):
1317 Puts("(using backwards compatibility mode)\n");
1318 break;
1319 #endif /* BOOTINFO_COMPAT_1_0 */
1320
1321 default:
1322 Printf("\nThis bootstrap is too %s for this kernel!\n",
1323 boots_major < kernel_major ? "old" : "new");
1324 return(0);
1325 }
1326 return(kernel_major);
1327 }
1328
1329
1330 /*
1331 * Call the copy-and-go-code
1332 */
1333
1334 static void start_kernel(void (*startfunc)(), char *stackp, char *memptr,
1335 u_long start_mem, u_long mem_size, u_long rd_size,
1336 u_long kernel_size)
1337 {
1338 register void (*a0)() __asm("a0") = startfunc;
1339 register char *a2 __asm("a2") = stackp;
1340 register char *a3 __asm("a3") = memptr;
1341 register u_long a4 __asm("a4") = start_mem;
1342 register u_long d0 __asm("d0") = mem_size;
1343 register u_long d1 __asm("d1") = rd_size;
1344 register u_long d2 __asm("d2") = kernel_size;
1345 register u_long d3 __asm("d3") = bi_size;
1346
1347 __asm __volatile ("movel a2,sp;"
1348 "jmp a0@"
1349 : /* no outputs */
1350 : "r" (a0), "r" (a2), "r" (a3), "r" (a4), "r" (d0),
1351 "r" (d1), "r" (d2), "r" (d3)
1352 /* no return */);
1353 /* fake a noreturn */
1354 for (;;);
1355 }
1356
1357 asm(".text\n"
1358 ".align 4\n"
1359 SYMBOL_NAME_STR(_getvbr) ":
1360 movec vbr,d0
1361 rte
1362 ");
1363
1364
1365 /* LPSTOP cannot be used on the 68060. Apparently the
1366 CyberStorm bus design cannot cope with it.*/
1367 /* Just let the 68k hang for now. */
1368 asm(".text\n"
1369 ".align 4\n"
1370 SYMBOL_NAME_STR(_wedgie) ":
1371 stop #0x2700
1372 ");
1373
1374
1375 asm(".text\n"
1376 ".align 4\n"
1377 SYMBOL_NAME_STR(_probe_powerup) ":
1378 moveml d2/a5/a6,a7@-
1379 movel d0,a0
1380 leal 99f,a1
1381 movel a0@(8),d1
1382 movel a1,a0@(8)
1383 moveq #1,d0
1384
1385 leal 0xfffe0000,a1
1386 nop
1387 movel a1@,d2
1388 nop
1389 swap d2
1390 andil #0xff,d2
1391 bne 20f
1392
1393 nop
1394 clrl a1@(0x30)
1395 nop
1396 movel a1@,d2
1397 nop
1398 andil #3,d2
1399 bne 20f
1400
1401 nop
1402 movel #3,a1@(0x30)
1403 nop
1404 movel a1@,d2
1405 nop
1406 andil #3,d2
1407 cmpw #3,d2
1408 bne 20f
1409
1410 10: movel d1,a0@(8)
1411 moveml a7@+,d2/a5/a6
1412 rts
1413
1414 20: moveq #0,d0
1415 bra 10b
1416
1417 99: addql #2,a7@(2)
1418 moveq #0,d0
1419 rte
1420 ");
1421
1422 /*
1423 * This assembler code is copied to chip ram, and then executed.
1424 * It copies the kernel to it's final resting place.
1425 *
1426 * It is called with:
1427 *
1428 * a3 = memptr
1429 * a4 = start_mem
1430 * d0 = mem_size
1431 * d1 = rd_size
1432 * d2 = kernel_size
1433 * d3 = bi_size
1434 */
1435
1436 asm(".text\n"
1437 ".align 4\n"
1438 SYMBOL_NAME_STR(_copyall) ":
1439 | /* copy kernel text and data */
1440 movel a3,a0 | src = (u_long *)memptr;
1441 movel a0,a2 | limit = (u_long *)(memptr+kernel_size);
1442 addl d2,a2
1443 movel a4,a1 | dest = (u_long *)start_mem;
1444 1: cmpl a0,a2
1445 jeq 2f | while (src < limit)
1446 moveb a0@+,a1@+ | *dest++ = *src++;
1447 jra 1b
1448 2:
1449 | /* copy bootinfo to end of bss */
1450 movel a3,a0 | src = (u_long *)(memptr+kernel_size);
1451 addl d2,a0 | dest = end of bss (already in a1)
1452 movel d3,d7 | count = bi_size
1453 subql #1,d7
1454 1: moveb a0@+,a1@+ | while (--count > -1)
1455 dbra d7,1b | *dest++ = *src++
1456
1457 | /* copy the ramdisk to the top of memory */
1458 | /* (from back to front) */
1459 movel a4,a1 | dest = (u_long *)(start_mem+mem_size);
1460 addl d0,a1
1461 movel a3,a2 | limit = (u_long *)(memptr+kernel_size +
1462 addl d2,a2 | bi_size);
1463 addl d3,a2
1464 movel a2,a0 | src = (u_long *)((u_long)limit+rd_size);
1465 addl d1,a0
1466 1: cmpl a0,a2
1467 beqs 2f | while (src > limit)
1468 moveb a0@-,a1@- | *--dest = *--src;
1469 bras 1b
1470 2:
1471 | /* jump to start of kernel */
1472 movel a4,a0 | jump_to (start_mem);
1473 jmp a0@
1474 "
1475 SYMBOL_NAME_STR(_copyallend) ":
1476 ");
1477
1478
1479 /*
1480 * Test for a MapROMmed A3640 Board
1481 */
1482
1483 asm(".text\n"
1484 ".align 4\n"
1485 SYMBOL_NAME_STR(_maprommed) ":
1486 oriw #0x0700,sr
1487 moveml #0x3f20,sp@-
1488 | /* Save cache settings */
1489 .long 0x4e7a1002 | movec cacr,d1 */
1490 | /* Save MMU settings */
1491 .long 0x4e7a2003 | movec tc,d2
1492 .long 0x4e7a3004 | movec itt0,d3
1493 .long 0x4e7a4005 | movec itt1,d4
1494 .long 0x4e7a5006 | movec dtt0,d5
1495 .long 0x4e7a6007 | movec dtt1,d6
1496 moveq #0,d0
1497 movel d0,a2
1498 | /* Disable caches */
1499 .long 0x4e7b0002 | movec d0,cacr
1500 | /* Disable MMU */
1501 .long 0x4e7b0003 | movec d0,tc
1502 .long 0x4e7b0004 | movec d0,itt0
1503 .long 0x4e7b0005 | movec d0,itt1
1504 .long 0x4e7b0006 | movec d0,dtt0
1505 .long 0x4e7b0007 | movec d0,dtt1
1506 lea 0x07f80000,a0
1507 lea 0x00f80000,a1
1508 movel a0@,d7
1509 cmpl a1@,d7
1510 jne 1f
1511 movel d7,d0
1512 notl d0
1513 movel d0,a0@
1514 nop | /* Thanks to Jörg Mayer! */
1515 cmpl a1@,d0
1516 jne 1f
1517 moveq #-1,d0 | /* MapROMmed A3640 present */
1518 movel d0,a2
1519 1: movel d7,a0@
1520 | /* Restore MMU settings */
1521 .long 0x4e7b2003 | movec d2,tc
1522 .long 0x4e7b3004 | movec d3,itt0
1523 .long 0x4e7b4005 | movec d4,itt1
1524 .long 0x4e7b5006 | movec d5,dtt0
1525 .long 0x4e7b6007 | movec d6,dtt1
1526 | /* Restore cache settings */
1527 .long 0x4e7b1002 | movec d1,cacr
1528 movel a2,d0
1529 moveml sp@+,#0x04fc
1530 rte
1531 ");
1532
1533
1534 /*
1535 * Reset functions for nasty Zorro boards
1536 */
1537
1538 static void reset_rb3(const struct ConfigDev *cd)
1539 {
1540 volatile u_char *rb3_reg = (u_char *)(cd->cd_BoardAddr+0x01002000);
1541
1542 /* FN: If a Rainbow III board is present, reset it to disable */
1543 /* its (possibly activated) vertical blank interrupts as the */
1544 /* kernel is not yet prepared to handle them (level 6). */
1545
1546 /* set RESET bit in special function register */
1547 *rb3_reg = 0x01;
1548 /* actually, only a few cycles delay are required... */
1549 Sleep(1000000);
1550 /* clear reset bit */
1551 *rb3_reg = 0x00;
1552 }
1553
1554 static void reset_piccolo(const struct ConfigDev *cd)
1555 {
1556 volatile u_char *piccolo_reg = (u_char *)(cd->cd_BoardAddr+0x8000);
1557
1558 /* FN: the same stuff as above, for the Piccolo board. */
1559 /* this also has the side effect of resetting the board's */
1560 /* output selection logic to use the Amiga's display in single */
1561 /* monitor systems - which is currently what we want. */
1562
1563 /* set RESET bit in special function register */
1564 *piccolo_reg = 0x01;
1565 /* actually, only a few cycles delay are required... */
1566 Sleep(1000000);
1567 /* clear reset bit */
1568 *piccolo_reg = 0x51;
1569 }
1570
1571 static void reset_sd64(const struct ConfigDev *cd)
1572 {
1573 volatile u_char *sd64_reg = (u_char *)(cd->cd_BoardAddr+0x8000);
1574
1575 /* FN: the same stuff as above, for the SD64 board. */
1576 /* just as on the Piccolo, this also resets the monitor switch */
1577
1578 /* set RESET bit in special function register */
1579 *sd64_reg = 0x1f;
1580 /* actually, only a few cycles delay are required... */
1581 Sleep(1000000);
1582 /* clear reset bit AND switch monitor bit (0x20) */
1583 *sd64_reg = 0x4f;
1584 }
1585
1586 static void reset_a2065(const struct ConfigDev *cd)
1587 {
1588 volatile u_short *lance_rdp = (u_short *)(cd->cd_BoardAddr+0x4000);
1589 volatile u_short *lance_rap = (u_short *)(cd->cd_BoardAddr+0x4002);
1590
1591 Disable();
1592
1593 /* Stop the card */
1594 *lance_rap = 0; /* PCnet-ISA Controller Status (CSR0) */
1595 *lance_rdp = 4; /* STOP */
1596
1597 Enable();
1598 }
1599
1600 static void reset_ariadne(const struct ConfigDev *cd)
1601 {
1602 volatile u_short *lance_rdp = (u_short *)(cd->cd_BoardAddr+0x0370);
1603 volatile u_short *lance_rap = (u_short *)(cd->cd_BoardAddr+0x0372);
1604 volatile u_short *lance_reset = (u_short *)(cd->cd_BoardAddr+0x0374);
1605
1606 volatile u_char *pit_paddr = (u_char *)(cd->cd_BoardAddr+0x1004);
1607 volatile u_char *pit_pbddr = (u_char *)(cd->cd_BoardAddr+0x1006);
1608 volatile u_char *pit_pacr = (u_char *)(cd->cd_BoardAddr+0x100b);
1609 volatile u_char *pit_pbcr = (u_char *)(cd->cd_BoardAddr+0x100e);
1610 volatile u_char *pit_psr = (u_char *)(cd->cd_BoardAddr+0x101a);
1611
1612 u_short in;
1613
1614 Disable();
1615
1616 /*
1617 * Reset the Ethernet part (Am79C960 PCnet-ISA)
1618 */
1619
1620 in = *lance_reset; /* Reset Chip on Read Access */
1621 *lance_rap = 0x0000; /* PCnet-ISA Controller Status (CSR0) */
1622 *lance_rdp = 0x0400; /* STOP */
1623
1624 /*
1625 * Reset the Parallel part (MC68230 PI/T)
1626 */
1627
1628 *pit_pacr &= 0xfd; /* Port A Control Register */
1629 *pit_pbcr &= 0xfd; /* Port B Control Register */
1630 *pit_psr = 0x05; /* Port Status Register */
1631 *pit_paddr = 0x00; /* Port A Data Direction Register */
1632 *pit_pbddr = 0x00; /* Port B Data Direction Register */
1633
1634 Enable();
1635 }
1636
1637 static void reset_hydra(const struct ConfigDev *cd)
1638 {
1639 volatile u_char *nic_cr = (u_char *)(cd->cd_BoardAddr+0xffe1);
1640 volatile u_char *nic_isr = (u_char *)(cd->cd_BoardAddr+0xffe1 + 14);
1641 int n = 5000;
1642
1643 Disable();
1644
1645 *nic_cr = 0x21; /* nic command register: software reset etc. */
1646 while (((*nic_isr & 0x80) == 0) && --n) /* wait for reset to complete */
1647 ;
1648
1649 Enable();
1650 }
1651
1652 #if 0
1653 static void reset_a2060(const struct ConfigDev *cd)
1654 {
1655 #error reset_a2060: not yet implemented
1656 }
1657 #endif
1658
1659
1660 #ifdef ZKERNEL
1661
1662 #define ZFILE_CHUNK_BITS 16 /* chunk is 64 KB */
1663 #define ZFILE_CHUNK_SIZE (1 << ZFILE_CHUNK_BITS)
1664 #define ZFILE_CHUNK_MASK (ZFILE_CHUNK_SIZE-1)
1665 #define ZFILE_N_CHUNKS (2*1024*1024/ZFILE_CHUNK_SIZE)
1666
1667 /* variables for storing the uncompressed data */
1668 static char *ZFile[ZFILE_N_CHUNKS];
1669 static int ZFileSize = 0;
1670 static int ZFpos = 0;
1671 static int Zwpos = 0;
1672
1673 static int Zinfd = 0; /* fd of compressed file */
1674
1675 /*
1676 * gzip declarations
1677 */
1678
1679 #define OF(args) args
1680
1681 #define memzero(s, n) memset ((s), 0, (n))
1682
1683 typedef unsigned char uch;
1684 typedef unsigned short ush;
1685 typedef unsigned long ulg;
1686
1687 #define INBUFSIZ 4096
1688 #define WSIZE 0x8000 /* window size--must be a power of two, and */
1689 /* at least 32K for zip's deflate method */
1690
1691 static uch *inbuf;
1692 static uch *window;
1693
1694 static unsigned insize = 0; /* valid bytes in inbuf */
1695 static unsigned inptr = 0; /* index of next byte to be processed in inbuf */
1696 static unsigned outcnt = 0; /* bytes in output buffer */
1697 static int exit_code = 0;
1698 static long bytes_out = 0;
1699
1700 #define get_byte() (inptr < insize ? inbuf[inptr++] : fill_inbuf())
1701
1702 /* Diagnostic functions (stubbed out) */
1703 #define Assert(cond,msg)
1704 #define Trace(x)
1705 #define Tracev(x)
1706 #define Tracevv(x)
1707 #define Tracec(c,x)
1708 #define Tracecv(c,x)
1709
1710 #define STATIC static
1711
1712 static int fill_inbuf(void);
1713 static void flush_window(void);
1714 static void error(char *m);
1715 static void gzip_mark(void **);
1716 static void gzip_release(void **);
1717
1718 #define malloc(x) AllocVec(x, MEMF_FAST | MEMF_PUBLIC)
1719 #define free(x) FreeVec(x)
1720
1721 #ifdef LILO
1722 #include "inflate.c"
1723 #else
1724 #include "../../../../lib/inflate.c"
1725 #endif
1726
1727 static void gzip_mark(void **ptr)
1728 {
1729 }
1730
1731 static void gzip_release(void **ptr)
1732 {
1733 }
1734
1735
1736 /*
1737 * Fill the input buffer. This is called only when the buffer is empty
1738 * and at least one byte is really needed.
1739 */
1740 static int fill_inbuf(void)
1741 {
1742 if (exit_code)
1743 return -1;
1744
1745 insize = Read(Zinfd, inbuf, INBUFSIZ);
1746 if (insize <= 0)
1747 return -1;
1748
1749 inptr = 1;
1750 return(inbuf[0]);
1751 }
1752
1753 /*
1754 * Write the output window window[0..outcnt-1] and update crc and bytes_out.
1755 * (Used for the decompressed data only.)
1756 */
1757 static void flush_window(void)
1758 {
1759 ulg c = crc; /* temporary variable */
1760 unsigned n;
1761 uch *in, ch;
1762 int chunk = Zwpos >> ZFILE_CHUNK_BITS;
1763
1764 if (exit_code)
1765 return;
1766
1767 if (chunk >= ZFILE_N_CHUNKS) {
1768 error("Compressed image too large! Aborting.\n");
1769 return;
1770 }
1771 if (!ZFile[chunk]) {
1772 if (!(ZFile[chunk] = (char *)AllocMem(ZFILE_CHUNK_SIZE,
1773 MEMF_FAST | MEMF_PUBLIC))) {
1774 error("Out of memory for decompresing kernel image\n");
1775 return;
1776 }
1777 }
1778 memcpy(ZFile[chunk] + (Zwpos & ZFILE_CHUNK_MASK), window, outcnt);
1779 Zwpos += outcnt;
1780
1781 #define DISPLAY_BITS 10
1782 if ((Zwpos & ((1 << DISPLAY_BITS)-1)) == 0)
1783 PutChar('.');
1784
1785 in = window;
1786 for (n = 0; n < outcnt; n++) {
1787 ch = *in++;
1788 c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8);
1789 }
1790 crc = c;
1791 bytes_out += (ulg)outcnt;
1792 outcnt = 0;
1793 }
1794
1795 static void error(char *x)
1796 {
1797 Printf("\n%s", x);
1798 exit_code = 1;
1799 }
1800
1801 static inline int call_sub(int (*func)(void), void *stackp)
1802 {
1803 register int _res __asm("d0");
1804 register int (*a0)(void) __asm("a0") = func;
1805 register int (*a1)(void) __asm("a1") = stackp;
1806
1807 __asm __volatile ("movel sp,a2;"
1808 "movel a1,sp;"
1809 "jsr a0@;"
1810 "movel a2,sp"
1811 : "=r" (_res)
1812 : "r" (a0), "r" (a1)
1813 : "a0", "a1", "a2", "d0", "d1", "memory");
1814 return(_res);
1815 }
1816
1817 static int load_zkernel(int fd)
1818 {
1819 int i, err = -1;
1820 #define ZSTACKSIZE (16384)
1821 u_long *zstack;
1822
1823 for (i = 0; i < ZFILE_N_CHUNKS; ++i)
1824 ZFile[i] = NULL;
1825 Zinfd = fd;
1826 Seek(fd, 0);
1827
1828 if (!(inbuf = (uch *)AllocMem(INBUFSIZ, MEMF_FAST | MEMF_PUBLIC)))
1829 Puts("Couldn't allocate gunzip buffer\n");
1830 else {
1831 if (!(window = (uch *)AllocMem(WSIZE, MEMF_FAST | MEMF_PUBLIC)))
1832 Puts("Couldn't allocate gunzip window\n");
1833 else {
1834 if (!(zstack = (u_long *)AllocMem(ZSTACKSIZE,
1835 MEMF_FAST | MEMF_PUBLIC)))
1836 Puts("Couldn't allocate gunzip stack\n");
1837 else {
1838 Puts("Uncompressing kernel image ");
1839 makecrc();
1840 if (!(err = call_sub(gunzip, (char *)zstack+ZSTACKSIZE)))
1841 Puts("done\n");
1842 ZFileSize = Zwpos;
1843 FreeMem(zstack, ZSTACKSIZE);
1844 }
1845 FreeMem(window, WSIZE);
1846 window = NULL;
1847 }
1848 FreeMem(inbuf, INBUFSIZ);
1849 inbuf = NULL;
1850 }
1851 Close(Zinfd); /* input file not needed anymore */
1852 return(err);
1853 }
1854
1855
1856 /* Note about the read/lseek wrapper and its memory management: It assumes
1857 * that all seeks are only forward, and thus data already read or skipped can
1858 * be freed. This is true for current organization of bootstrap and kernels.
1859 * Little exception: The struct kexec at the start of the file. After reading
1860 * it, there may be a seek back to the end of the file. But this currently
1861 * doesn't hurt. (Roman)
1862 */
1863
1864 static int KRead(int fd, void *buf, int cnt)
1865 {
1866 unsigned done = 0;
1867
1868 if (!ZFileSize)
1869 return(Read(fd, buf, cnt));
1870
1871 if (ZFpos + cnt > ZFileSize)
1872 cnt = ZFileSize - ZFpos;
1873
1874 while (cnt > 0) {
1875 unsigned chunk = ZFpos >> ZFILE_CHUNK_BITS;
1876 unsigned endchunk = (chunk+1) << ZFILE_CHUNK_BITS;
1877 unsigned n = cnt;
1878
1879 if (ZFpos + n > endchunk)
1880 n = endchunk - ZFpos;
1881 memcpy(buf, ZFile[chunk] + (ZFpos & ZFILE_CHUNK_MASK), n);
1882 cnt -= n;
1883 buf += n;
1884 done += n;
1885 ZFpos += n;
1886
1887 if (ZFpos == endchunk) {
1888 FreeMem(ZFile[chunk], ZFILE_CHUNK_SIZE);
1889 ZFile[chunk] = NULL;
1890 }
1891 }
1892
1893 return(done);
1894 }
1895
1896
1897 static int KSeek(int fd, int offset)
1898 {
1899 unsigned oldpos, oldchunk, newchunk;
1900
1901 if (!ZFileSize)
1902 return(Seek(fd, offset));
1903
1904 oldpos = ZFpos;
1905 ZFpos = offset;
1906 if (ZFpos < 0) {
1907 ZFpos = 0;
1908 return(-1);
1909 } else if (ZFpos > ZFileSize) {
1910 ZFpos = ZFileSize;
1911 return(-1);
1912 }
1913
1914 /* free memory of skipped-over data */
1915 oldchunk = oldpos >> ZFILE_CHUNK_BITS;
1916 newchunk = ZFpos >> ZFILE_CHUNK_BITS;
1917 while(oldchunk < newchunk) {
1918 if (ZFile[oldchunk]) {
1919 FreeMem(ZFile[oldchunk], ZFILE_CHUNK_SIZE);
1920 ZFile[oldchunk] = NULL;
1921 }
1922 ++oldchunk;
1923 }
1924 return(ZFpos);
1925 }
1926
1927
1928 static void free_zfile(void)
1929 {
1930 int i;
1931
1932 for (i = 0; i < ZFILE_N_CHUNKS; ++i)
1933 if (ZFile[i]) {
1934 FreeMem(ZFile[i], ZFILE_CHUNK_SIZE);
1935 ZFile[i] = NULL;
1936 }
1937 }
1938
1939 static int KClose(int fd)
1940 {
1941 if (ZFileSize) {
1942 free_zfile();
1943 ZFileSize = 0;
1944 } else
1945 Close(fd);
1946 return(0);
1947 }
1948 #endif /* ZKERNEL */
1949
Mirror of AROS' svn.