application: Factor out the configure_push_buttons() function.

application: Factor out the reset_requested() function.

No change in behavior.

application: Set up pins for the MX25L flash memory.

This configures SPI0 as well as the GPIO used as the flash's
chip select line.

common: Implement Storage::read() in Mx25l.

common: Add the storage module.

application: Perform system reset from panic handler if requested.

This is untested; I'm not sure if it would work at all.

common: Add the mx25l module.

Provides access to the status register and device ID only for now.

common: Accept DGPS fix information.

We used to reject differential GPS (DGPS) fixes as invalid, but they
are actually more accurate than standard GPS fixes.

common: Increase size of the UART receive ringbuffer.

The GPS module sends about ~380 bytes per second, which led to
overflows of our 256 byte sized ringbuffer.

common: Add the spi module.

common: Restart NMEA message parsing when a '$' character is seen.

The GPS module sometimes sends incomplete NMEA messages such as this:
  $GP$GGA...*
This changeset makes it so we'd only parse the second, complete message
in that example.

tools: Pad final chunks with 0xff if necessary.

The bootloader only accepts chunks whose size is a multiple of four.

common: Move panic handler out of libcommon.

This allows us to do a native build of libcommon which is useful for
unit testing.

application: Show current time on the display if we have a GPS fix.

common: Implement Time::fmt_time().

Formats time as HH:MM:SS.

common: Add the time module.

This currently only contains the equivalent of gmtime(), which was
adapted from Rich Felker's musl.

common: Add the fmt module.

common: Implement screen::clear() and screen::draw_text().

This also imports (a subset of) Frederic Cambus' spleen font,
used by screen::draw_text().

common: Tweak bit order of screen data.

The left-most pixel is now defined by the most significant bit.
This is a more intuitive representation than what we had before.

application: Visualize GPS fix state using the satellite icons.

As long as we are waiting for a GPS fix, we animate the satellite
icons.

application: Manage whether or not we have valid GPS fix information.

Expire such information after about 1.5s.

application: Blink heart icon to indicate liveness.

common: Implement display::show_icon() and display::hide_icon().

This only supports the alarm, heart and satellite icons for now,
but not the battery meter icon.

application: Extract time and position from GPS NMEA messages.

common: Add the gps module.

application: Set up pins for the GPS.

This configures UART0 as well as the GPS' reset line.

application: Define UART0_IRQHandler().

Writes received data to the global uart0_rx_buf ringbuffer.

common: Add Rust glue for the ringbuf module.

For now this only allows us to access a ringbuffer from Rust
after it has been defined in C code.

common: Add the uart module.

application: Enable OSC0.

Needed for UART0.

common: Implement clock::enable_osc0().

build: Use rustc to link the binaries instead of gcc.

This simplifies the build system by removing the need for
libapplication.a, libbootloader.a and the two start.c copies.

bootloader: Mark jump_to_application() as noreturn.

build: Link libgcc from the command line instead of the linker script.

Pulling it in via the linker script will only work if we use our
C toolchain's linker and would fail if we used the Rust linker.

build: Don't link libraries we don't need.

application: Initialize and clear the display on startup.

application: Set up pins for the display.

This configures I2C0 as well as the GPIO used to control the display's
reset line.

common: Add the display module.

It currently can initialize, clear and draw the main area
of the display. Drawing or clearing the icon area is not yet
supported.

application: Perform a system reset if PTA12 is pressed.

application: Configure PTA12 for push button use.

common: Implement nvic::system_reset().

Performs a system reset.

bootloader: Never auto-start the application in the intermediate bootloader.

Instead, we now always enter bootloader operation. I think this has
less potential of bricking a device in case you don't press PTE24
fast enough after installing the intermediate bootloader.

common: Add the i2c module.

bootloader: Call clock::reset() before jumping to the application.

By switching back to FBE clock mode there, we can unconditionally
do the switches to FBE, PBE and PEE in any of our programs.

common: Implement clock::reset().

This puts the MCG back into FBE mode.

common: Combine writes to SIM_CLKDIV1 in clock::configure_clkdiv().

By setting both CLKDIV1 and CLKDIV4 at the same time we avoid
running the flash at twice the intended clock rate for a couple
of cycles which has been observed to make it read bad data.

bootloader: Disable the watchdog.

The watchdog gets enabled with a 1s timeout on POR, and I don't
want to deal with that.

common: Add the watchdog module.

For now this only lets us disable the COP watchdog.

application: Explicitly enable global interrupts.

The bootloader now longer leaves them enabled before it jumps
to the application, so we need to enable them explicitly.

bootloader: Sanitize global interrupt handling.

We now disable interrupts before jumping to application,
as overwriting the VTOR with interrupts enabled is rather risky.

Also don't assume that interrupts are enabled when the bootloader
is run -- enable them explicitly when we need them.

common: Implement enable_interrupts() and disable_interrupts().

common: Disable the USB interrupt in usb_serial::shutdown().

bootloader: Use the same maximum size for both bootloaders.

This sets the maximum size of the intermediate bootloader to the
one that we (have to) use for the final bootloader, too.

I don't see the point in allowing more code in the intermediate
bootloader anymore.

bootloader: Reimplement flash::run_command() in C.

While running a flash command that operates on a given flash block,
executing code from that same flash block will cause read-while-write
errors that lock up the core.

Thus we need to ensure that no interrupt handler will execute
during that time, and we also need to relocate the respective
flash code to RAM.

bootloader: Use distinct USB PIDs depending on location in flash.

The intermediate bootloader binary (located at 0x8000) now uses
USB PID 0x635b and the final bootloader binary (located at 0x0)
uses USB PID 0x635c.

This lets us find out what binary we're talking to depending on
how it registers on the USB.

bootloader: Explicitly initialize the port module.

Don't assume another component does it for us.

common: Implement port::init().

This function powers up ports A, B, C, D and E.

application: Add humble beginnings of the application code.

This is just a USB serial hello world right now.

common: Fix two -Wold-style-declaration warnings.

This fixes the following warnings:

virtual_com.c:105:1: warning: 'static' is not at beginning of declaration
 volatile static uint32_t s_recvSize = 0;
 ^~~~~~~~
virtual_com.c:106:1: warning: 'static' is not at beginning of declaration
 volatile static uint8_t s_sendComplete = 0;
 ^~~~~~~~

common: Remove unused variable s_sendSize from virtual_com.c.

bootloader: Stop USB serial device before entering the application.

Try to provide a clean slate to the application.

common: Wrap USB_VcomDeinit() in usb_serial::shutdown().

common: USB_VcomDeinit() always shuts down the singleton CDC device.

This removes the function's argument.

common: Don't attempt to stop the USB clock in USB_VcomDeinit().

We don't implement that functionality yet.

bootloader: Only attempt to jump to application if there is any.

We now read the first word from flash where the application is
installed and compare against 0xffffffff to see if programming
succeeded.

bootloader: Import bootloader-final.ld.

This is used to link the final bootloader described in the
previous commit.

bootloader: Rename bootloader.ld to bootloader-intermediate.ld.

We will need two bootloader binaries eventually: an intermediate one
that we can install to 0x8000 using the vendor bootloader, and a
final one that is installed to 0x0 and will thus replace the vendor
bootloader.

tools: Don't try to erase and program the second flash sector.

The bootloader refuses to erase that sector anyway. Consequences are
that we may not put any code in the second sector and that we
will get verification errors for that sector.

bootloader: Refuse to erase the second flash sector.

The second flash sector (address 0x400) stores the flash configuration
field -- resetting the MCU with 0xff stored in there bricks the device.

bootloader: Only begin serial communication if PTE24 is held down.

bootloader: configure PTE24 for push button use.

common: Add the gpio module.

common: Add the port module.

bootloader: Initialize systick on startup.

common: Add the systick module.

This implements various timer functions using the systick peripheral.

tools: Add support for COMMAND_START_APP.

May be combined with the write or verify commands, but it can also
be used on its own.

bootloader: Use USB VID 0xf055 and PID 0x635c.

common: Make USB_VcomInit() take VID/PID and pass them on.

common: Add USB_DeviceSetVendorId() and USB_DeviceSetProductId().

These configure the VID/PID pair to use.

common: Initialize the usb_serial module with an USB VID and PID pair.

No change in behaviour yet, as the IDs are not yet forwarded to
the USB system proper.

bootloader: Jump to application code after serial communication is done.

bootloader: Define application offset.

This defines the APPLICATION_ADDR constant and sets it to the
offset of the vector table to jump to after the bootloader is done.

common: Implement jump_to_application().

bootloader: Make run() function return a bool.

The return value indicates if the caller should continue to call
the function. It only returns false once COMMAND_START_APP is seen.

The idea is that after run() returns false, the we can jump to the
application code.

bootloader: Prepare implementation of COMMAND_START_APP.

This command is to instruct the bootloader to jump to the application.
It doesn't do anything yet.

common: Remove unused function USB_VcomWriteBlocking().

common: Remove unused function USB_VcomReadBlocking().

common: Remove prototype for undefined function USB_VcomReadPolling().

tools: Add firmware updater.

bootloader: Call into the bootloader module from main().

bootloader: Add the bootloader module.

This implements a simple serial protocol that offers access to the
capabilities of the flash module, i.e. erase, program and verify
flash contents.

common: Implement the transmit path for the USB serial module.

This adds the global variable cdc_tx_buf, which buffers data
to be written to USB.

common: Implement the receive path for the USB serial module.

This sets up a ringbuffer for data received from the USB host.
When we try to read from the empty ringbuffer, another receive-data
request is sent.

Other modules can read from this ringbuffer via the new
usb_serial_read() function.

common: Add the ringbuf module.

common: Add the buffer module.

This comes with a C API, so it can be used by the USB serial code.

bootloader: Add the flash module.

Offers functions to erase a flash sector, program a flash sector and
verify a flash sector's contents.

Note that we don't clear the flash controller's cache by writing to
MCM_PLACR after erasing or programming sectors since it doesn't seem
to be required.

common: Add the crc32 module.

common: Define panic handler using the #[panic_handler] attribute.

This means we now require rust 1.30 for the build.

common: Implement USB0 interrupt handler.

With this change, the device successfully registers as a USB ACM device
and doesn't hard fault if it's disconnected from USB.

common: Implement USB_DeviceIsrEnable() and USB_DeviceClockInit().

These functions are required by the C implementation.