xref: /haiku/src/system/boot/platform/next_m68k/start.cpp (revision 10bba152b3d5d0f55621871ab7660aab0877cdfc)

/*
 * Copyright 2008-2020, François Revol, revol@free.fr. All rights reserved.
 * Copyright 2003-2010, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include <KernelExport.h>
#include <boot/platform.h>
#include <boot/heap.h>
#include <boot/stage2.h>
#include <arch/cpu.h>

#include <string.h>

#include "console.h"
#include "cpu.h"
#include "mmu.h"
#include "keyboard.h"
#include "nextrom.h"


// GCC defined globals
extern void (*__ctor_list)(void);
extern void (*__ctor_end)(void);
extern uint8 __bss_start;
extern uint8 _end;

extern "C" int main(stage2_args *args);
extern "C" void _start(void);

// the boot rom monitor entry point
struct mon_global *mg = NULL;

static uint32 sBootOptions;


static void
clear_bss(void)
{
	memset(&__bss_start, 0, &_end - &__bss_start);
}


static void
call_ctors(void)
{
	void (**f)(void);

	for (f = &__ctor_list; f < &__ctor_end; f++) {
		(**f)();
	}
}


extern "C" uint32
platform_boot_options(void)
{
#if 0
	if (!gKernelArgs.fb.enabled)
		sBootOptions |= check_for_boot_keys();
#endif
	return sBootOptions;
}


extern "C" void
platform_start_kernel(void)
{
#if 0
	static struct kernel_args *args = &gKernelArgs;
		// something goes wrong when we pass &gKernelArgs directly
		// to the assembler inline below - might be a bug in GCC
		// or I don't see something important...
	addr_t stackTop
		= gKernelArgs.cpu_kstack[0].start + gKernelArgs.cpu_kstack[0].size;

	preloaded_elf32_image *image = static_cast<preloaded_elf32_image *>(
		gKernelArgs.kernel_image.Pointer());

	//smp_init_other_cpus();
	//serial_cleanup();
	mmu_init_for_kernel();
	//smp_boot_other_cpus();

#warning M68K: stop ints

	dprintf("kernel entry at %lx\n", image->elf_header.e_entry);

	asm volatile (
		"move.l	%0,%%sp;	"			// move stack out of way
		: : "m" (stackTop));

	asm volatile (
		"or	#0x0700,%%sr; " : : );		// disable interrupts

	asm volatile (
		"move.l  #0x0,-(%%sp); "		// we're the BSP cpu (0)
		"move.l 	%0,-(%%sp);	"		// kernel args
		"move.l 	#0x0,-(%%sp);"		// dummy retval for call to main
		"move.l 	%1,-(%%sp);	"		// this is the start address
		"rts;		"					// jump.
		: : "g" (args), "g" (image->elf_header.e_entry));

	// Huston, we have a problem!

	asm volatile (
		"and	#0xf8ff,%%sr; " : : );		// reenable interrupts

	panic("kernel returned!\n");
#endif

}


extern "C" void
platform_exit(void)
{
	// TODO
	while (true);
}

inline void dump_mg(struct mon_global *mg)
{
	int i;
	dprintf("mg@ %p\n", (void*)mg);

	dprintf("mg_flags\t%x\n", (unsigned char)mg->mg_flags);
	dprintf("mg_sid\t%x\n", mg->mg_sid);
	dprintf("mg_pagesize\t%x\n", mg->mg_pagesize);
	dprintf("mg_mon_stack\t%x\n", mg->mg_mon_stack);
	dprintf("mg_vbr\t%x\n", mg->mg_vbr);
	dprintf("mg_console_i\t%x\n", mg->mg_console_i);
	dprintf("mg_console_o\t%x\n", mg->mg_console_o);

	for (i = 0; i < N_SIMM; i++) {
		dprintf("mg_region[%d] = {%08lx, %08lx}\n", i,
				mg->mg_region[i].first_phys_addr,
				mg->mg_region[i].last_phys_addr);
	}

	dprintf("mg_boot_dev\t%s\n", mg->mg_boot_dev);
	dprintf("mg_boot_arg\t%s\n", mg->mg_boot_arg);
	dprintf("mg_boot_info\t%s\n", mg->mg_boot_info);
	dprintf("mg_boot_file\t%s\n", mg->mg_boot_file);
	dprintf("mg_boot_dev\t%s\n", mg->mg_boot_dev);
	dprintf("mg_boot_how\t%d\n", mg->mg_boot_how);

	dprintf("mg_sddp\t%p\n", mg->mg_sddp);
	dprintf("mg_dgp\t%p\n", mg->mg_dgp);
		// "dlV3" (disk label signature ?) SCSI boot gives "@dlV3"
	dprintf("mg_fdgp\t%p\n", mg->mg_fdgp);	// "A" ?? SCSI: "to become ready"
	dprintf("mg_s5cp\t%p\n", mg->mg_s5cp);
	dprintf("mg_odc\t%p\n", mg->mg_odc);
	dprintf("mg_odd\t%p\n", mg->mg_odd);

#if 0
	for (int i = 0; i < sizeof(struct mon_global); i++) {
		uint8 *p = ((uint8 *)mg)+i;
		if (i % 32 == 0)
			dprintf("%04x", i);
		if (i % 4 == 0)
			dprintf(" ");
		if (i % 8 == 0)
			dprintf(" ");
		dprintf("%02x", *p);
		if (i % 32 == 31 || i == sizeof(struct mon_global) - 1)
			dprintf("\n");
	}
	//while(true);
#endif


	dprintf("mg_si\t%p\n", mg->mg_si);
	/* XXX:the pointer seems completely random, sadly.
	 * Possibly the kernel is supposed to set it?
	 */
#if 0
	for (int i = 0; i < sizeof(struct sio); i++) {
		uint8 *p = ((uint8 *)mg->mg_si)+i;
		if (i % 32 == 0)
			dprintf("%04x", i);
		if (i % 4 == 0)
			dprintf(" ");
		if (i % 8 == 0)
			dprintf(" ");
		dprintf("%02x", *p);
		if (i % 32 == 31 || i == sizeof(struct sio) - 1)
			dprintf("\n");
	}
	for (i = 0; i < 5; i++) {
		struct sio *s = &mg->mg_si[i];
		dprintf("sio[%d] = {%08x, %u, %u, %u, %p, %u, %u, %p, %p, %p}\n", i,
				s->si_args, s->si_ctrl, s->si_unit, s->si_part,
				s->si_dev, s->si_blklen, s->si_lastlba,
				s->si_sadmem, s->si_protomem, s->si_devmem);
		s++;
	}
#endif

	//dprintf("test_msg\t%p\n", mg->test_msg);
	/* Framebuffer info */
#if 1
	dprintf("km_coni = {%d, %d, %d, %d, %d, ... %d, %d, %d, ...%d}\n",
			mg->km_coni.pixels_per_word,
			mg->km_coni.bytes_per_scanline,
			mg->km_coni.dspy_w,
			mg->km_coni.dspy_max_w,
			mg->km_coni.dspy_h,
			//...
			mg->km_coni.slot_num,
			mg->km_coni.fb_num,
			mg->km_coni.byte_lane_id,
			mg->km_coni.access_stack);
	for (i = 0; i < KM_CON_MAP_ENTRIES; i++) {
		dprintf("km_coni.map_addr[%d] = {%08lx, %08lx, %08lx}\n", i,
				mg->km_coni.map_addr[i].phys_addr,
				mg->km_coni.map_addr[i].virt_addr,
				mg->km_coni.map_addr[i].size);
	}
#endif

	//XXX: this one crashes on older ROMs
	//dprintf("mg_cpu_clk\t%d\n", mg->mg_cpu_clk);
}


extern "C" void *
start_next(const char *boot_args, struct mon_global *monitor)
{
	stage2_args args;

	monitor->mg_putc('H');

	//asm("cld");			// Ain't nothing but a GCC thang.
	//asm("fninit");		// initialize floating point unit

	//clear_bss();
	/* save monitor ROM entry */
	mg = monitor;
	// DEBUG
	mg->mg_putc('A');

	call_ctors();
		// call C++ constructors before doing anything else
	mg->mg_putc('I');

	args.heap_size = 0;
	args.arguments = NULL;

	//serial_init();
	mg->mg_putc('K');
	console_init();
	mg->mg_putc('U');
	mg->mg_putc('\n');

	dump_mg(mg);
	//while(1);
	//return NULL;
	cpu_init();
#if 0
	// TODO
	mmu_init();

	// wait a bit to give the user the opportunity to press a key
	spin(750000);

	// reading the keyboard doesn't seem to work in graphics mode (maybe a bochs problem)
	sBootOptions = check_for_boot_keys();
	//if (sBootOptions & BOOT_OPTION_DEBUG_OUTPUT)
		//serial_enable();

	//apm_init();
	//smp_init();
#endif
	main(&args);
	return NULL;
}