Now that we are adding our own target we can compile our own toolchain
instead of using the stock one. This does mean that there isn't really a
purpose to using the alpine cc65 image though
Now that the ROM is just a bootloader and the kernel is stored on the SD
card, we do not need to be constantly changing the ROM.
Disabling the memory editor dramatically reduces compilation time which
will be useful when implementing FPGA features in the future.
Instead of using the bootsector to load a bootloader, just put the
bootloader in the ROM and call it a day. It looks for a file on the SD
card in the root directory named `kernel.bin` and loads it into memory.
This is not a perfect solution, as the kernel will grow larger and the
kernel load address will have to change. At this point I could add back
the bootloader, but that is for later.
Also the bootloader is just a copy of the kernel, so that can be trimmed
down a lot.
I forgot that the CI still uses the stock cc65 which doesn't support my
target. The kernel doesn't really need this target though, only the user
programs.
Kernel is now compiled and linked into a raw binary instead of intel
hex. This raw binary can be loaded into the correct address by the
bootloader.
I wanted this to be an o65 file, but ld65 kept complaining about it.
Honestly though having this be a straight binary makes it easier to
load, but we can't relocate it.
The boot environment will read the boot sector from the sd card, verify
that it has the boot signature at the end, then jump to the start of it.
From there, there should be a bootloader written to the boot segment
that can handle the rest.
It might be tight to fit everything into the boot sector but do remember
that you do not have to initialize or select the sd card, and those
functions take up a lot of space.
This allows you to find the cluster number of a file in the root
directory by name. The main program is a simple demo where you can type
in a filename and it will tell you the cluster number.
Eventually I want the kernel to be loaded from the SD card as well, but
it still needs to separate from user programs.
At some point there should be a folder just for the BIOS, which should
read from the boot block of the SD card and start executing, and thats
it.
All of the SD card commands are moved into their own file, with
functions sd_init, sd_get_rca, sd_select_card, sd_get_status, and
sd_readblock.
The FAT functions are movied into fat.c and give functions fat_init and
fat_read. Note that the filename is ignored for now, it always reads the
first file in the root directory.
The loading of o65 files is done in o65.c, and executing is done in
exec.c
This cleans up the main file signifigantly and leaves the project open
to expansion.
This will read the data from the sd card, copy it to the originally
linked address (no relocation), then execute it.
I am lazy and wrote it in C using weird function pointer casting but
this would probably be more efficient if it were to be written in
assembly instead.
The test program simply returns 'A', but that is enough to prove that it
is actually running.
This adds a test program which can be loaded and executed by the host.
It simply returns a value in the `a` register.
The linker script is modified so that it will output an o65 file, and
the memory sgments are changed as well. There is no STARTUP segment
defined, so it uses the default `none` crt0, which sets up the stack
and does initialization and deconstruction.
The Makefile is modified to not turn the output into an intel hex file,
and instead keep it as the o65 file.
Prints out information about the drive, now inside its own function.
Also changes the read function to take in a 32 bit address instead of a
16 bit one.
Attempts to read the first file on the disk
