The iSerial descriptor now holds the firmware version number.  This is
1.0.0 since I don't expect any major API changes any time soon.  The USB
descriptors have been documented in docs/console_config.md so there
will be no questions as to how to identify the devices and what their
"serial numbers" mean.

The VID:PID pair 1209:9DB5 is now officially assigned for the PD Buddy
Sink.  Thanks, Arachnid!  Now the firmware uses its proper PID instead
of the testing one.

The most useful thing from the stack of scratch paper I made while
designing the firmware.  Now it's immortalized as an SVG.

As the name suggests, it clears all the flags in the configuration
buffer.  This provides a way to easily set all the flags to a known
state, which is nice for implementing libraries that configure PD Buddy
Sink devices.

There's not really any harm in writing a configuration with zero voltage
or current (and it was possible all along anyway), so why fight it?

Since the firmware is under 32 KiB, I figured there's not much reason to
use a microcontroller with 128 KiB of flash.  The new boards use
STM32F072x8 chips, which only have 64 KiB of flash.  This allows for the
firmware to grow, while not being quite so ridiculous as before.

This commit sets the Makefile to put the configuration at the end of the
64 KiB flash chip, and to use a new linker script for the same chip.

That's the name of the board now, so the configuration should match.

It's more obvious what is meant by that macro than by just the number
100.

It's very important to document the format in which configuration is
printed, since being able to reliably read the configuration is
essential to implementing configuration GUIs.  Now it's documented, and
the format is considered stable.

Now there's a docs/ directory for storing our documentation in!

The manufacturer should be PD Buddy, and the product should be Sink.
And so it is.

Now we correctly set the GiveBack flag and minimum current fields in the
Request message when GiveBack is enabled.  Also when GiveBack is
enabled, we correctly handle GotoMin messages by lowering our power
consumption, completing negotiation, and Requesting our normal power
periodically until the power supply Accepts our Request.

At least, I believe it's correct.  I don't have any hardware that sends
GotoMin messages, so I can't test it other than that it doesn't break
anything with the GiveBack flag set to 1 or 0 when the source doesn't
ask to reduce power.

As the name says, it toggles the GiveBack flag in the configuration
buffer.  The rest of the firmware doesn't use the flag for anything yet,
but it is correctly saved in flash.

We used to free the Request we made after transmitting it.  However, for
GiveBack to work properly, we need to be able to make that request
again.  To do it without having to request the Source_Capabilities
again, it makes sense to keep the Request message in memory.  We have
more messages in the pool than we need anyway.

The policy engine is supposed to transition to the
PE_SNK_Transition_to_default state from any state when hard reset
signaling is received.  While it still doesn't do that exactly, in every
state that already waited for events, the PDB_EVT_PE_RESET event is also
checked, with the appropriate transition being made if the event is
received.

My justification for not checking for the event in other states is that
if there's no wait, the reset will be received soon by another state
anyway.  Besides, if there's no event handling already, where exactly
would be best to insert a test for the event?

I think so, anyway.  Testing with a heat gun didn't result in the Sink
resetting itself, so I'm not confident that I understand the FUSB302B's
over-temperature sensing mechanism.

I must point out though that I'm not confident that this
over-temperature protection is even useful.  The PD Buddy Sink doesn't
get hot on its own, and if it did, it might not even be from the device
it's powering, making a hard reset useless.  The spec says that we Shall
implement over temperature protection though, and that we Shall send a
Hard Reset message when it engages, so even though I take issue with the
requirement, I'll try to do what the standard says I Shall.

The README now outlines the features of the PD Buddy Firmware.

A bit of documentation was added to main.c, along with renaming the
pd_buddy() function to sink().

When there is a positive or negative transition of Vbus, we Shall reduce
our power consumption to no more than 2.5 W beforehand.  This can be
easily achieved in all cases by simply turning off the output. This was
implemented, so that's one fewer Shall we aren't doing.

In the process, I made some API changes for the Device Policy Manager.
No more output_on() and output_off(), now it's output_set(true) and
output_set(false), plus a special case output_default() used during a
hard reset.  This much better matches how these functions are used by
the policy engine.

Before, we were doing the O(1) configuration loading operation every
15 ms, which just made me feel dirty.  Now we do it only the first time
we check the available Type-C Current, and then cache its location.
This works because it never moves without rebooting into setup mode.

Type-C Current is a mechanism defined in the USB Type-C spec for
indicating high-current modes at 5 V using nothing other than a voltage
on the CC line.  The FUSB302B maps the voltage to one of the four ranges
we care about, so it's easy to see if 1.5 A or 3 A is available at 5 V
even in systems that don't support PD.

Now, when the PD Buddy Sink is connected to a system without Power
Delivery support, after all attempts at PD communications fail, it falls
back to Type-C Current.  If the Sink is configured for 5 V, it will
monitor the CC line's voltage to see if enough Type-C Current is
available.  If so, the output is turned on.

After a failed hard reset, we keep trying to negotiate power.  Before,
the LED was on steady indicating negotiation failure during these
continued negotiations.  Now it keeps blinking, indicating what's
actually going on.

It was a uint8_t before, but it was really just a boolean variable.
It's a proper bool now, and the code that sets its value is less
ridiculous.

It's simpler than I realized.  All that's left to do here is the
fallback mechanism for when the Sink is configured for 5 V.  This means
that yet again, a TODO was replaced with another, less critical TODO.

Before, it was repetitive and hard to expand.  It would have become a
big ugly decision tree upon adding support for variable and battery
PDOs.

Now it's been refactored to be a procedure, appending PDOs to the end of
the list and building the message header at the end.  The code isn't
repetitive, and new features can be added more easily.

In the PE_SNK_Select_Capability state, we Shall do some transitions if
we receive a Wait or Reject message.  Now we do.  This creates another
TODO (running SinkRequestTimer in the PE_SNK_Ready state), but this
one's only for a Should, not a Shall.

Now we use more consistent language to refer to the stored configuration
(which is in flash) and the configuration buffer (RAM).

The repositories have been moved to the PD Buddy organization.

Ultimately the handling will be more interesting than this.  For now
though, we don't support them, and so we Shall reject them.

From the USB PD spec, Revision 2.0, S. 6.4.4.1:

* A DFP or UFP which does not support Unstructured VDMs Shall Ignore
  any Unstructured VDMs received.

From S. 6.4.4.2:

* A DFP or UFP which does not support Structured VDMs Shall Ignore any
  Structured VDMs received.

Therefore, as long as we do not support any VDMs, we Shall Ignore them,
which is exactly what we're doing.  We're not doing anything wrong, so I
removed the TODO comment that implied we were doing something wrong.

Now that there's a decent GUI, we can at least mention that it exists in
the README.  It's good to make people aware of their options, you know?

Also, I got tired of the inline URLs, so I changed the links to be of
the footnote type.  It's much nicer looking e.g. in the list of firmware
flashing programs.

PD uses odd units for voltages and currents.  Power too, but we don't
work with power (yet).  In the shell, we have to convert to and from
these odd units.  We had been doing this in-place every time, which was
a bit crumby.  Now it's done with macros in pd.h, making prettier and
more maintainable code.