Added a command shell and storage functions

The command shell is based on the ChibiOS-provided one, but modified to
not run in a new thread and generally be a bit simpler, while also
having PD Buddy branding.  The storage functions work with the STM32
flash registers directly, taking over the last page of flash.  A new
linker script is used to ensure that program code can't end up using
that page.  The DPM has been updated to use the saved settings rather
than hardcoded ones.  Now what's needed is real commands for editing the
configuration.

Added commands to edit configuration

We now have commands to load the current settings into RAM, edit the
settings in RAM, and write them back to flash.  The only settings
currently supported are current and fixed voltage, because the rest of
the code doesn't support GiveBack or variable/battery PDOs yet.

Short help messages were added for each command.  Nothing too exciting,
but it should be a great help for someone poking around in the PD Buddy
Sink configuration shell for the first time.

Wrote new usage information for the firmware

Now that we have a command shell, the README should indicate how to use
it.

Makefile

@@ -30,7 +30,7 @@ endif
 
 # Enable this if you want link time optimizations (LTO)
 ifeq ($(USE_LTO),)
-  USE_LTO = yes
+  USE_LTO = no
 endif
 
 # If enabled, this option allows to compile the application in THUMB mode.
@@ -96,7 +96,7 @@ include $(CHIBIOS)/os/rt/ports/ARMCMx/compilers/GCC/mk/port_v6m.mk
 include $(CHIBIOS)/test/rt/test.mk
 
 # Define linker script file here
-LDSCRIPT= $(STARTUPLD)/STM32F072xB.ld
+LDSCRIPT=$(CHIBIOS)/../ld/STM32F072xB.ld
 
 # C sources that can be compiled in ARM or THUMB mode depending on the global
 # setting.
@@ -108,6 +108,7 @@ CSRC = $(STARTUPSRC) \
        $(PLATFORMSRC) \
        $(BOARDSRC) \
        $(TESTSRC) \
+       $(CHIBIOS)/os/hal/lib/streams/chprintf.c \
        $(wildcard src/*.c)
 
 # C++ sources that can be compiled in ARM or THUMB mode depending on the global
@@ -139,7 +140,7 @@ ASMSRC = $(STARTUPASM) $(PORTASM) $(OSALASM)
 
 INCDIR = $(STARTUPINC) $(KERNINC) $(PORTINC) $(OSALINC) \
          $(HALINC) $(PLATFORMINC) $(BOARDINC) $(TESTINC) \
-         $(CHIBIOS)/os/various \
+         $(CHIBIOS)/os/hal/lib/streams $(CHIBIOS)/os/various \
 	 config
 
 #
@@ -190,7 +191,7 @@ CPPWARN = -Wall -Wextra -Wundef
 #
 
 # List all user C define here, like -D_DEBUG=1
-UDEFS =
+UDEFS = -DPDB_CONFIG_BASE=0x0801F800
 
 # Define ASM defines here
 UADEFS =

README.md

@@ -59,7 +59,34 @@ OpenOCD can also be used to flash the firmware.  For example:
 
 ## Usage
 
-Currently, there isn't much to say here.  Plug it into your power supply, and
-the PD Buddy Sink will negotiate 2.25 A at 20 V.  This can be configured by
-editing `dpm_desired_v` and `dpm_desired_i` in `src/device_policy_manager.c`,
-then recompiling and reflashing.
+After first flashing the PD Buddy Sink, the device has no configuration.  To
+configure it, plug it into your computer while holding the "Setup" button.  The
+LED should blink once per second to indicate that the device is in
+configuration mode.  The Sink provides a virtual serial port for editing its
+configuration.
+
+### Configuration with the Serial Terminal
+
+Connect to the PD Buddy Sink with your favorite serial console program, such as
+GNU Screen, Minicom, or PuTTY.  Press Enter, and you should be greeted with a
+`PDBS)` prompt.  The `help` command gives brief summaries of each of the
+available commands.
+
+To configure the PD Buddy Sink to request 2.25 A at 20 V, run the following
+commands:
+
+    PDBS) set_v 20000
+    PDBS) set_i 2250
+    PDBS) write
+
+When `write` is run, the chosen settings are written to flash.  You can then
+simply disconnect the Sink from your computer.
+
+### Using the configured PD Buddy Sink
+
+Once the Sink has been configured, just plug it into your USB PD power supply.
+If the supply is capable of putting out the configured current at the
+configured voltage, the Sink will negotiate it, then turn on its output and
+blink the LED three times to indicate success.  If the supply cannot output
+enough power, the Sink will turn its LED on solid to indicate failure, and
+leave its output turned off.

chconf.h

@@ -352,7 +352,7 @@
  *
  * @note    The default is @p FALSE.
  */
-#define CH_DBG_SYSTEM_STATE_CHECK           TRUE
+#define CH_DBG_SYSTEM_STATE_CHECK           FALSE
 
 /**
  * @brief   Debug option, parameters checks.
@@ -361,7 +361,7 @@
  *
  * @note    The default is @p FALSE.
  */
-#define CH_DBG_ENABLE_CHECKS                TRUE
+#define CH_DBG_ENABLE_CHECKS                FALSE
 
 /**
  * @brief   Debug option, consistency checks.
@@ -371,7 +371,7 @@
  *
  * @note    The default is @p FALSE.
  */
-#define CH_DBG_ENABLE_ASSERTS               TRUE
+#define CH_DBG_ENABLE_ASSERTS               FALSE
 
 /**
  * @brief   Debug option, trace buffer.
@@ -380,7 +380,7 @@
  *
  * @note    The default is @p FALSE.
  */
-#define CH_DBG_ENABLE_TRACE                 TRUE
+#define CH_DBG_ENABLE_TRACE                 FALSE
 
 /**
  * @brief   Debug option, stack checks.
@@ -392,7 +392,7 @@
  * @note    The default failure mode is to halt the system with the global
  *          @p panic_msg variable set to @p NULL.
  */
-#define CH_DBG_ENABLE_STACK_CHECK           TRUE
+#define CH_DBG_ENABLE_STACK_CHECK           FALSE
 
 /**
  * @brief   Debug option, stacks initialization.
@@ -402,7 +402,7 @@
  *
  * @note    The default is @p FALSE.
  */
-#define CH_DBG_FILL_THREADS                 TRUE
+#define CH_DBG_FILL_THREADS                 FALSE
 
 /**
  * @brief   Debug option, threads profiling.

halconf.h

@@ -157,7 +157,7 @@
  * @brief   Enables the SERIAL over USB subsystem.
  */
 #if !defined(HAL_USE_SERIAL_USB) || defined(__DOXYGEN__)
-#define HAL_USE_SERIAL_USB          FALSE
+#define HAL_USE_SERIAL_USB          TRUE
 #endif
 
 /**
@@ -178,7 +178,7 @@
  * @brief   Enables the USB subsystem.
  */
 #if !defined(HAL_USE_USB) || defined(__DOXYGEN__)
-#define HAL_USE_USB                 FALSE
+#define HAL_USE_USB                 TRUE
 #endif
 
 /**

ld/STM32F072xB.ld

@@ -0,0 +1,53 @@
+/*
+    ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+/*
+ * STM32F072xB memory setup.
+ *
+ * Flash is defined as 2k smaller than it really is to reserve the last page
+ * for configuration.
+ */
+MEMORY
+{
+    flash : org = 0x08000000, len = 126k
+    ram0  : org = 0x20000000, len = 16k
+    ram1  : org = 0x00000000, len = 0
+    ram2  : org = 0x00000000, len = 0
+    ram3  : org = 0x00000000, len = 0
+    ram4  : org = 0x00000000, len = 0
+    ram5  : org = 0x00000000, len = 0
+    ram6  : org = 0x00000000, len = 0
+    ram7  : org = 0x00000000, len = 0
+}
+
+/* RAM region to be used for Main stack. This stack accommodates the processing
+   of all exceptions and interrupts*/
+REGION_ALIAS("MAIN_STACK_RAM", ram0);
+
+/* RAM region to be used for the process stack. This is the stack used by
+   the main() function.*/
+REGION_ALIAS("PROCESS_STACK_RAM", ram0);
+
+/* RAM region to be used for data segment.*/
+REGION_ALIAS("DATA_RAM", ram0);
+
+/* RAM region to be used for BSS segment.*/
+REGION_ALIAS("BSS_RAM", ram0);
+
+/* RAM region to be used for the default heap.*/
+REGION_ALIAS("HEAP_RAM", ram0);
+
+INCLUDE rules.ld

mcuconf.h

@@ -59,11 +59,11 @@
 #define STM32_PLS                           STM32_PLS_LEV0
 #define STM32_HSI_ENABLED                   TRUE
 #define STM32_HSI14_ENABLED                 TRUE
-#define STM32_HSI48_ENABLED                 TRUE
+#define STM32_HSI48_ENABLED                 FALSE
 #define STM32_LSI_ENABLED                   TRUE
 #define STM32_HSE_ENABLED                   FALSE
 #define STM32_LSE_ENABLED                   FALSE
-#define STM32_SW                            STM32_SW_HSI48
+#define STM32_SW                            STM32_SW_PLL
 #define STM32_PLLSRC                        STM32_PLLSRC_HSI_DIV2
 #define STM32_PREDIV_VALUE                  1
 #define STM32_PLLMUL_VALUE                  12
@@ -209,7 +209,7 @@
 /*
  * SERIAL driver system settings.
  */
-#define STM32_SERIAL_USE_USART1             TRUE
+#define STM32_SERIAL_USE_USART1             FALSE
 #define STM32_SERIAL_USE_USART2             FALSE
 #define STM32_SERIAL_USART1_PRIORITY        3
 #define STM32_SERIAL_USART2_PRIORITY        3
@@ -253,7 +253,7 @@
 /*
  * USB driver system settings.
  */
-#define STM32_USB_USE_USB1                  FALSE
+#define STM32_USB_USE_USB1                  TRUE
 #define STM32_USB_LOW_POWER_ON_SUSPEND      FALSE
 #define STM32_USB_USB1_LP_IRQ_PRIORITY      3
 

src/device_policy_manager.c

@@ -23,19 +23,17 @@
 #include <hal.h>
 
 #include "led.h"
+#include "storage.h"
 #include "pd.h"
 
 
-/* The voltage and current we want */
-/* XXX In the future, these won't be *quite* so convenient to access */
-static uint16_t dpm_desired_v = 400; /* 0.05 V increments */
-static uint16_t dpm_desired_i = 225; /* 0.01 A increments */
-
 /* Whether or not the power supply is unconstrained */
 static uint8_t dpm_unconstrained_power;
 
 bool pdb_dpm_evaluate_capability(const union pd_msg *capabilities, union pd_msg *request)
 {
+    /* Get the current configuration */
+    struct pdb_config *cfg = pdb_config_flash_read();
     /* Get the number of PDOs */
     uint8_t numobj = PD_NUMOBJ_GET(capabilities);
 
@@ -49,24 +47,27 @@ bool pdb_dpm_evaluate_capability(const union pd_msg *capabilities, union pd_msg
         dpm_unconstrained_power = 0;
     }
 
-    /* Look at the PDOs to see if one matches our desires */
-    for (uint8_t i = 0; i < numobj; i++) {
-        /* Fixed Supply PDOs come first, so when we see a PDO that isn't a
-         * Fixed Supply, stop reading. */
-        if ((capabilities->obj[i] & PD_PDO_TYPE) != PD_PDO_TYPE_FIXED) {
-            break;
-        }
-        /* If the V from the PDO equals our desired V and the I is at least our
-         * desired I */
-        if (PD_PDO_SRC_FIXED_VOLTAGE_GET(capabilities, i) == dpm_desired_v
-                && PD_PDO_SRC_FIXED_CURRENT_GET(capabilities, i) >= dpm_desired_i) {
-            /* We got what we wanted, so build a request for that */
-            request->hdr = PD_MSGTYPE_REQUEST | PD_DATAROLE_UFP |
-                PD_SPECREV_2_0 | PD_POWERROLE_SINK | PD_NUMOBJ(1);
-            request->obj[0] = PD_RDO_FV_MAX_CURRENT_SET(dpm_desired_i)
-                | PD_RDO_FV_CURRENT_SET(dpm_desired_i)
-                | PD_RDO_NO_USB_SUSPEND | PD_RDO_OBJPOS_SET(i + 1);
-            return true;
+    /* Make sure we have configuration */
+    if (cfg != NULL) {
+        /* Look at the PDOs to see if one matches our desires */
+        for (uint8_t i = 0; i < numobj; i++) {
+            /* Fixed Supply PDOs come first, so when we see a PDO that isn't a
+             * Fixed Supply, stop reading. */
+            if ((capabilities->obj[i] & PD_PDO_TYPE) != PD_PDO_TYPE_FIXED) {
+                break;
+            }
+            /* If the V from the PDO equals our desired V and the I is at least
+             * our desired I */
+            if (PD_PDO_SRC_FIXED_VOLTAGE_GET(capabilities, i) == cfg->v
+                    && PD_PDO_SRC_FIXED_CURRENT_GET(capabilities, i) >= cfg->i) {
+                /* We got what we wanted, so build a request for that */
+                request->hdr = PD_MSGTYPE_REQUEST | PD_DATAROLE_UFP |
+                    PD_SPECREV_2_0 | PD_POWERROLE_SINK | PD_NUMOBJ(1);
+                request->obj[0] = PD_RDO_FV_MAX_CURRENT_SET(cfg->i)
+                    | PD_RDO_FV_CURRENT_SET(cfg->i)
+                    | PD_RDO_NO_USB_SUSPEND | PD_RDO_OBJPOS_SET(i + 1);
+                return true;
+            }
         }
     }
     /* Nothing matched, so get 5 V */
@@ -81,15 +82,27 @@ bool pdb_dpm_evaluate_capability(const union pd_msg *capabilities, union pd_msg
 
 void pdb_dpm_get_sink_capability(union pd_msg *cap)
 {
+    /* Get the current configuration */
+    struct pdb_config *cfg = pdb_config_flash_read();
+
+    /* If we have no configuration, request 0.1 A at 5 V. */
+    if (cfg == NULL) {
+        /* Sink_Capabilities message */
+        cap->hdr = PD_MSGTYPE_SINK_CAPABILITIES | PD_DATAROLE_UFP
+            | PD_SPECREV_2_0 | PD_POWERROLE_SINK | PD_NUMOBJ(1);
+        /* vSafe5V at the desired current. */
+        cap->obj[0] = PD_PDO_TYPE_FIXED
+            | PD_PDO_SNK_FIXED_VOLTAGE_SET(100)
+            | PD_PDO_SNK_FIXED_CURRENT_SET(10);
     /* If we want 5 V, we need to send only one PDO */
-    if (dpm_desired_v == 100) {
+    } else if (cfg->v == 100) {
         /* Sink_Capabilities message */
         cap->hdr = PD_MSGTYPE_SINK_CAPABILITIES | PD_DATAROLE_UFP
             | PD_SPECREV_2_0 | PD_POWERROLE_SINK | PD_NUMOBJ(1);
         /* vSafe5V at the desired current. */
         cap->obj[0] = PD_PDO_TYPE_FIXED
-            | PD_PDO_SNK_FIXED_VOLTAGE_SET(dpm_desired_v)
-            | PD_PDO_SNK_FIXED_CURRENT_SET(dpm_desired_i);
+            | PD_PDO_SNK_FIXED_VOLTAGE_SET(cfg->v)
+            | PD_PDO_SNK_FIXED_CURRENT_SET(cfg->i);
     /* Otherwise, send two PDOs, one for 5 V and one for the desired power. */
     } else {
         /* Sink_Capabilities message */
@@ -101,8 +114,8 @@ void pdb_dpm_get_sink_capability(union pd_msg *cap)
             | PD_PDO_SNK_FIXED_CURRENT_SET(10);
         /* Next, desired_v and desired_i */
         cap->obj[1] = PD_PDO_TYPE_FIXED
-            | PD_PDO_SNK_FIXED_VOLTAGE_SET(dpm_desired_v)
-            | PD_PDO_SNK_FIXED_CURRENT_SET(dpm_desired_i);
+            | PD_PDO_SNK_FIXED_VOLTAGE_SET(cfg->v)
+            | PD_PDO_SNK_FIXED_CURRENT_SET(cfg->i);
     }
 
     /* Set the unconstrained power flag. */

src/led.c

@@ -47,7 +47,7 @@ static THD_FUNCTION(LED, arg) {
      * modes. */
     systime_t timeout = TIME_INFINITE;
     /* Counter for blinking modes */
-    int i;
+    int i = 0;
 
     while (true) {
         /* Wait for any event except the last one we saw */

src/main.c

@@ -35,6 +35,11 @@
 #include <ch.h>
 #include <hal.h>
 
+#include "chprintf.h"
+
+#include "shell.h"
+#include "usbcfg.h"
+
 #include "priorities.h"
 #include "led.h"
 #include "policy_engine.h"
@@ -61,9 +66,23 @@ static void setup(void)
     chEvtSignal(pdb_led_thread, PDB_EVT_LED_SLOW_BLINK);
 
     /* TODO: implement the configuration mode */
+    usbDisconnectBus(serusbcfg.usbp);
+
+    sduObjectInit(&SDU1);
+    sduStart(&SDU1, &serusbcfg);
+
+    chThdSleepMilliseconds(100);
+    usbStart(serusbcfg.usbp, &usbcfg);
+    usbConnectBus(serusbcfg.usbp);
+
+    //char text[] = "Hello, world!\r\n";
 
     while (true) {
-        chThdSleepMilliseconds(1000);
+        //sdWrite(&SDU1, (uint8_t *) text, 15);
+        //obqWriteTimeout(&SDU1.obqueue, (uint8_t *) text, 15, TIME_INFINITE);
+        //chprintf(&SDU1, "Hello, world! %d\r\n", ST2S(chVTGetSystemTime()));
+        pdb_shell();
+        chThdSleepMilliseconds(100);
     }
 }
 

src/shell.c

@@ -0,0 +1,341 @@
+/*
+ * PD Buddy - USB Power Delivery for everyone
+ * Copyright (C) 2017 Clayton G. Hobbs <clay@lakeserv.net>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+    ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#include "shell.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <ch.h>
+
+#include "chprintf.h"
+
+#include "usbcfg.h"
+#include "storage.h"
+
+
+/* Buffer for unwritten configuration */
+static struct pdb_config tmpcfg = {
+    .status = PDB_CONFIG_STATUS_EMPTY
+};
+
+static void cmd_erase(BaseSequentialStream *chp, int argc, char *argv[])
+{
+    (void) argv;
+    if (argc > 0) {
+        chprintf(chp, "Usage: erase\r\n");
+        return;
+    }
+
+    pdb_config_flash_erase();
+}
+
+static void cmd_write(BaseSequentialStream *chp, int argc, char *argv[])
+{
+    (void) argv;
+    if (argc > 0) {
+        chprintf(chp, "Usage: write\r\n");
+        return;
+    }
+
+    pdb_config_flash_update(&tmpcfg);
+}
+
+static void cmd_load(BaseSequentialStream *chp, int argc, char *argv[])
+{
+    (void) argv;
+    if (argc > 0) {
+        chprintf(chp, "Usage: load\r\n");
+        return;
+    }
+
+    /* Get the current configuration */
+    struct pdb_config *cfg = pdb_config_flash_read();
+    if (cfg == NULL) {
+        chprintf(chp, "No configuration\r\n");
+        return;
+    }
+
+    /* Load the current configuration into tmpcfg */
+    tmpcfg.status = cfg->status;
+    tmpcfg.flags = cfg->flags;
+    tmpcfg.v = cfg->v;
+    tmpcfg.i = cfg->i;
+    tmpcfg.v_min = cfg->v_min;
+    tmpcfg.v_max = cfg->v_max;
+}
+
+static void cmd_get_cfg(BaseSequentialStream *chp, int argc, char *argv[])
+{
+    struct pdb_config *cfg = NULL;
+
+    if (argc > 1) {
+        chprintf(chp, "Usage: get_cfg [index]\r\n");
+        return;
+    }
+
+    /* With no arguments, find the current configuration */
+    if (argc == 0) {
+        cfg = pdb_config_flash_read();
+        if (cfg == NULL) {
+            chprintf(chp, "No configuration\r\n");
+            return;
+        }
+    /* With an argument, get a particular configuration array index */
+    } else if (argc == 1) {
+        char *endptr;
+        long i = strtol(argv[0], &endptr, 0);
+        if (i >= 0 && i < PDB_CONFIG_ARRAY_LEN && endptr > argv[0]) {
+            cfg = &pdb_config_array[i];
+        } else {
+            chprintf(chp, "Invalid index\r\n");
+            return;
+        }
+    }
+    /* Print the configuration */
+    pdb_config_print(chp, cfg);
+}
+
+static void cmd_get_tmpcfg(BaseSequentialStream *chp, int argc, char *argv[])
+{
+    (void) argv;
+    if (argc > 0) {
+        chprintf(chp, "Usage: get_tmpcfg [index]\r\n");
+        return;
+    }
+
+    pdb_config_print(chp, &tmpcfg);
+}
+
+static void cmd_set_v(BaseSequentialStream *chp, int argc, char *argv[])
+{
+    if (argc != 1) {
+        chprintf(chp, "Usage: set_v voltage_in_mV\r\n");
+        return;
+    }
+
+    char *endptr;
+    long i = strtol(argv[0], &endptr, 0);
+    if (i >= 0 && i <= UINT16_MAX && endptr > argv[0]) {
+        tmpcfg.status = PDB_CONFIG_STATUS_VALID;
+        /* Convert mV to the unit used by USB PD */
+        /* XXX this could use a macro */
+        tmpcfg.v = i / 50;
+    } else {
+        chprintf(chp, "Invalid voltage\r\n");
+        return;
+    }
+}
+
+static void cmd_set_i(BaseSequentialStream *chp, int argc, char *argv[])
+{
+    if (argc != 1) {
+        chprintf(chp, "Usage: set_i current_in_mA\r\n");
+        return;
+    }
+
+    char *endptr;
+    long i = strtol(argv[0], &endptr, 0);
+    if (i >= 0 && i <= UINT16_MAX && endptr > argv[0]) {
+        tmpcfg.status = PDB_CONFIG_STATUS_VALID;
+        /* Convert mA to the unit used by USB PD */
+        /* XXX this could use a macro */
+        tmpcfg.i = i / 10;
+    } else {
+        chprintf(chp, "Invalid current\r\n");
+        return;
+    }
+}
+
+static const struct pdb_shell_cmd commands[] = {
+    {"erase", cmd_erase, "Erase all stored configuration"},
+    {"write", cmd_write, "Write the changes to flash"},
+    {"load", cmd_load, "Load the stored configuration into RAM"},
+    {"get_cfg", cmd_get_cfg, "Print the stored configuration"},
+    {"get_tmpcfg", cmd_get_tmpcfg, "Print the configuration buffer"},
+    /* TODO {"toggle_giveback", cmd_toggle_giveback, "Toggle the GiveBack flag"},*/
+    /* TODO {"toggle_var_bat", cmd_toggle_var_bat, "Toggle the Var/Bat flag"},*/
+    {"set_v", cmd_set_v, "Set the voltage in millivolts"},
+    {"set_i", cmd_set_i, "Set the current in milliamps"},
+    /* TODO {"set_v_range", cmd_set_v_range, "Set the minimum and maximum voltage in millivolts"},*/
+    {NULL, NULL, NULL}
+};
+
+const struct pdb_shell_cfg shell_cfg = {
+    (BaseSequentialStream *)&SDU1,
+    commands
+};
+
+/*
+ * Utility functions for the shell
+ */
+static char *_strtok(char *str, const char *delim, char **saveptr)
+{
+    char *token;
+    if (str)
+        *saveptr = str;
+    token = *saveptr;
+
+    if (!token)
+        return NULL;
+
+    token += strspn(token, delim);
+    *saveptr = strpbrk(token, delim);
+    if (*saveptr)
+        *(*saveptr)++ = '\0';
+
+    return *token ? token : NULL;
+}
+
+static void list_commands(BaseSequentialStream *chp, const struct pdb_shell_cmd *scp)
+{
+    while (scp->cmd != NULL) {
+        chprintf(chp, "\t%s: %s\r\n", scp->cmd, scp->desc);
+        scp++;
+    }
+}
+
+static bool cmdexec(const struct pdb_shell_cmd *scp, BaseSequentialStream *chp,
+        char *name, int argc, char *argv[])
+{
+    while (scp->cmd != NULL) {
+        if (strcmp(scp->cmd, name) == 0) {
+            scp->func(chp, argc, argv);
+            return false;
+        }
+        scp++;
+    }
+    return true;
+}
+
+/*
+ * PD Buddy configuration shell
+ *
+ * p: The configuration for the shell itself
+ */
+void pdb_shell(void)
+{
+    int n;
+    BaseSequentialStream *chp = shell_cfg.io;
+    const struct pdb_shell_cmd *scp = shell_cfg.commands;
+    char *lp, *cmd, *tokp, line[PDB_SHELL_MAX_LINE_LENGTH];
+    char *args[PDB_SHELL_MAX_ARGUMENTS + 1];
+
+    while (true) {
+        chprintf(chp, "PDBS) ");
+        if (shellGetLine(chp, line, sizeof(line))) {
+            chprintf(chp, "\r\n");
+            continue;
+        }
+        lp = _strtok(line, " \t", &tokp);
+        cmd = lp;
+        n = 0;
+        while ((lp = _strtok(NULL, " \t", &tokp)) != NULL) {
+            if (n >= PDB_SHELL_MAX_ARGUMENTS) {
+                chprintf(chp, "too many arguments\r\n");
+                cmd = NULL;
+                break;
+            }
+            args[n++] = lp;
+        }
+        args[n] = NULL;
+        if (cmd != NULL) {
+            if (strcmp(cmd, "help") == 0) {
+                if (n > 0) {
+                    chprintf(chp, "Usage: help\r\n");
+                    continue;
+                }
+                chprintf(chp, "PD Buddy Sink configuration shell\r\n");
+                chprintf(chp, "Commands:\r\n");
+                chprintf(chp, "\thelp: Print this message\r\n");
+                if (scp != NULL)
+                    list_commands(chp, scp);
+            }
+            else if ((scp == NULL) || cmdexec(scp, chp, cmd, n, args)) {
+                chprintf(chp, "%s", cmd);
+                chprintf(chp, " ?\r\n");
+            }
+        }
+    }
+    return;
+}
+
+
+/**
+ * @brief   Reads a whole line from the input channel.
+ *
+ * @param[in] chp       pointer to a @p BaseSequentialStream object
+ * @param[in] line      pointer to the line buffer
+ * @param[in] size      buffer maximum length
+ * @return              The operation status.
+ * @retval true         the channel was reset or CTRL-D pressed.
+ * @retval false        operation successful.
+ *
+ * @api
+ */
+bool shellGetLine(BaseSequentialStream *chp, char *line, unsigned size)
+{
+    char *p = line;
+
+    while (true) {
+        char c;
+
+        if (chSequentialStreamRead(chp, (uint8_t *)&c, 1) == 0)
+            return true;
+        if (c == 4) {
+            chprintf(chp, "^D");
+            return true;
+        }
+        if ((c == 8) || (c == 127)) {
+            if (p != line) {
+                chSequentialStreamPut(chp, 0x08);
+                chSequentialStreamPut(chp, 0x20);
+                chSequentialStreamPut(chp, 0x08);
+                p--;
+            }
+            continue;
+        }
+        if (c == '\r') {
+            chprintf(chp, "\r\n");
+            *p = 0;
+            return false;
+        }
+        if (c < 0x20)
+            continue;
+        if (p < line + size - 1) {
+            chSequentialStreamPut(chp, c);
+            *p++ = (char)c;
+        }
+    }
+}

src/shell.h

@@ -0,0 +1,63 @@
+/*
+ * PD Buddy - USB Power Delivery for everyone
+ * Copyright (C) 2017 Clayton G. Hobbs <clay@lakeserv.net>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+   ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#ifndef PDB_SHELL_H
+#define PDB_SHELL_H
+
+#include <ch.h>
+
+#define PDB_SHELL_MAX_LINE_LENGTH 64
+#define PDB_SHELL_MAX_ARGUMENTS 2
+
+
+/* Structure for PD Buddy shell commands */
+struct pdb_shell_cmd {
+    char *cmd;
+    void (*func)(BaseSequentialStream *chp, int argc, char *argv[]);
+    char *desc;
+};
+
+/* Structure for PD Buddy shell configuration */
+struct pdb_shell_cfg {
+    BaseSequentialStream *io;
+    const struct pdb_shell_cmd *commands;
+};
+
+
+void pdb_shell(void);
+
+bool shellGetLine(BaseSequentialStream *chp, char *line, unsigned size);
+
+
+#endif /* PDB_SHELL_H */

src/storage.c

@@ -0,0 +1,231 @@
+/*
+ * PD Buddy - USB Power Delivery for everyone
+ * Copyright (C) 2017 Clayton G. Hobbs <clay@lakeserv.net>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "storage.h"
+
+#include "chprintf.h"
+
+
+struct pdb_config *pdb_config_array = (struct pdb_config *) PDB_CONFIG_BASE;
+
+
+void pdb_config_print(BaseSequentialStream *chp, const struct pdb_config *cfg)
+{
+    /* Print the status */
+    chprintf(chp, "status: ");
+    switch (cfg->status) {
+        case PDB_CONFIG_STATUS_INVALID:
+            chprintf(chp, "in");
+            /* fall-through */
+        case PDB_CONFIG_STATUS_VALID:
+            chprintf(chp, "valid\r\n");
+            break;
+        case PDB_CONFIG_STATUS_EMPTY:
+            chprintf(chp, "empty\r\n");
+            /* Stop early because the rest of the information is meaningless in
+             * this case. */
+            return;
+        default:
+            chprintf(chp, "%04X\r\n", cfg->status);
+            break;
+    }
+
+    /* Print the flags */
+    chprintf(chp, "flags: ");
+    if (cfg->flags == 0) {
+        chprintf(chp, "(none)");
+    }
+    if (cfg->flags & PDB_CONFIG_FLAGS_GIVEBACK) {
+        chprintf(chp, "GiveBack ");
+    }
+    if (cfg->flags & PDB_CONFIG_FLAGS_VAR_BAT) {
+        chprintf(chp, "Var/Bat ");
+    }
+    chprintf(chp, "\r\n");
+
+    /* Print voltages and current */
+    chprintf(chp, "v: %d.%02d V\r\n", cfg->v/20, 5*(cfg->v%20));
+    chprintf(chp, "i: %d.%02d A\r\n", cfg->i/100, cfg->i%100);
+    if (cfg->flags & PDB_CONFIG_FLAGS_VAR_BAT) {
+        chprintf(chp, "v_min: %d.%02d V\r\n", cfg->v_min/20, 5*(cfg->v_min%20));
+        chprintf(chp, "v_max: %d.%02d V\r\n", cfg->v_max/20, 5*(cfg->v_max%20));
+    }
+}
+
+/*
+ * Unlock the flash interface
+ */
+static void flash_unlock(void)
+{
+    /* Wait till no operation is on going */
+    while ((FLASH->SR & FLASH_SR_BSY) != 0) {
+        /* Note: we might want a timeout here */
+    }
+
+    /* Check that the Flash is locked */
+    if ((FLASH->CR & FLASH_CR_LOCK) != 0) {
+        /* Perform unlock sequence */
+        FLASH->KEYR = FLASH_KEY1;
+        FLASH->KEYR = FLASH_KEY2;
+    }
+}
+
+/*
+ * Lock the flash interface
+ */
+static void flash_lock(void)
+{
+    /* Wait till no operation is on going */
+    while ((FLASH->SR & FLASH_SR_BSY) != 0) {
+        /* Note: we might want a timeout here */
+    }
+
+    /* Check that the Flash is unlocked */
+    if ((FLASH->CR & FLASH_CR_LOCK) == 0) {
+        /* Lock the flash */
+        FLASH->CR |= FLASH_CR_LOCK;
+    }
+}
+
+/*
+ * Write one halfword to flash
+ */
+static void flash_write_halfword(uint16_t *addr, uint16_t data)
+{
+    /* Set the PG bit in the FLASH_CR register to enable programming */
+    FLASH->CR |= FLASH_CR_PG;
+    /* Perform the data write (half-word) at the desired address */
+    *(__IO uint16_t*)(addr) = data;
+    /* Wait until the BSY bit is reset in the FLASH_SR register */
+    while ((FLASH->SR & FLASH_SR_BSY) != 0) {
+        /* For robust implementation, add here time-out management */
+    }
+    /* Check the EOP flag in the FLASH_SR register */
+    if ((FLASH->SR & FLASH_SR_EOP) != 0) {
+        /* clear it by software by writing it at 1 */
+        FLASH->SR = FLASH_SR_EOP;
+    } else {
+        /* Manage the error cases */
+    }
+    /* Reset the PG Bit to disable programming */
+    FLASH->CR &= ~FLASH_CR_PG;
+}
+
+/*
+ * Erase the configuration page, without any locking
+ */
+static void flash_erase(void)
+{
+    /* Set the PER bit in the FLASH_CR register to enable page erasing */
+    FLASH->CR |= FLASH_CR_PER;
+    /* Program the FLASH_AR register to select a page to erase */
+    FLASH->AR = (int) pdb_config_array;
+    /* Set the STRT bit in the FLASH_CR register to start the erasing */
+    FLASH->CR |= FLASH_CR_STRT;
+    /* Wait till no operation is on going */
+    while ((FLASH->SR & FLASH_SR_BSY) != 0) {
+        /* Note: we might want a timeout here */
+    }
+    /* Check the EOP flag in the FLASH_SR register */
+    if ((FLASH->SR & FLASH_SR_EOP) != 0) {
+        /* Clear EOP flag by software by writing EOP at 1 */
+        FLASH->SR = FLASH_SR_EOP;
+    } else {
+        /* Manage the error cases */
+    }
+    /* Reset the PER Bit to disable the page erase */
+    FLASH->CR &= ~FLASH_CR_PER;
+}
+
+void pdb_config_flash_erase(void)
+{
+    /* Enter a critical zone */
+    chSysLock();
+
+    flash_unlock();
+
+    /* Erase the flash page */
+    flash_erase();
+
+    flash_lock();
+
+    /* Exit the critical zone */
+    chSysUnlock();
+}
+
+void pdb_config_flash_update(const struct pdb_config *cfg)
+{
+    /* Enter a critical zone */
+    chSysLock();
+
+    flash_unlock();
+
+    /* If there is an old entry, invalidate it. */
+    struct pdb_config *old = pdb_config_flash_read();
+    if (old != NULL) {
+        flash_write_halfword(&(old->status), PDB_CONFIG_STATUS_INVALID);
+    }
+
+    /* Find the first empty entry */
+    struct pdb_config *empty = NULL;
+    for (int i = 0; i < PDB_CONFIG_ARRAY_LEN; i++) {
+        /* If we've found it, return it. */
+        if (pdb_config_array[i].status == PDB_CONFIG_STATUS_EMPTY) {
+            empty = &pdb_config_array[i];
+            break;
+        }
+    }
+    /* If empty is still NULL, the page is full.  Erase it. */
+    if (empty == NULL) {
+        flash_erase();
+        /* Write to the first element */
+        empty = &pdb_config_array[0];
+    }
+
+    /* Write the new configuration */
+    flash_write_halfword(&(empty->status), cfg->status);
+    flash_write_halfword(&(empty->flags), cfg->flags);
+    flash_write_halfword(&(empty->v), cfg->v);
+    flash_write_halfword(&(empty->i), cfg->i);
+    flash_write_halfword(&(empty->v_min), cfg->v_min);
+    flash_write_halfword(&(empty->v_max), cfg->v_max);
+
+    flash_lock();
+
+    /* Exit the critical zone */
+    chSysUnlock();
+}
+
+struct pdb_config *pdb_config_flash_read(void)
+{
+    /* If the first element is empty, there is no valid structure. */
+    if (pdb_config_array[0].status == PDB_CONFIG_STATUS_EMPTY) {
+        return NULL;
+    }
+
+    /* Find the valid structure, if there is one. */
+    for (int i = 0; i < PDB_CONFIG_ARRAY_LEN; i++) {
+        /* If we've found it, return it. */
+        if (pdb_config_array[i].status == PDB_CONFIG_STATUS_VALID) {
+            return &pdb_config_array[i];
+        }
+    }
+
+    /* If we got to the end, none of the structures is valid. */
+    return NULL;
+}

src/storage.h

@@ -0,0 +1,86 @@
+/*
+ * PD Buddy - USB Power Delivery for everyone
+ * Copyright (C) 2017 Clayton G. Hobbs <clay@lakeserv.net>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef PDB_STORAGE_H
+#define PDB_STORAGE_H
+
+#include <stdint.h>
+
+#include <ch.h>
+
+
+/*
+ * PD Buddy Sink configuration structure
+ */
+struct pdb_config {
+    uint16_t status;
+    uint16_t flags;
+    uint16_t v;
+    uint16_t i;
+    uint16_t v_min;
+    uint16_t v_max;
+    uint16_t _reserved[2];
+} __attribute__((packed));
+
+/* Status for configuration structures.  The empty status indicates that the
+ * struct is ready to be written, including an update to the valid status.
+ * Once the struct is no longer needed, the status is updated to invalid.
+ * Erasing the flash page resets all structures to the empty status. */
+#define PDB_CONFIG_STATUS_INVALID 0x0000
+#define PDB_CONFIG_STATUS_VALID 0xBEEF
+#define PDB_CONFIG_STATUS_EMPTY 0xFFFF
+
+/* Flags for configuration structures. */
+/* GiveBack supported */
+#define PDB_CONFIG_FLAGS_GIVEBACK 0x0001
+/* Variable and battery PDOs supported (v_min and v_max valid) */
+#define PDB_CONFIG_FLAGS_VAR_BAT 0x0002
+
+
+/* Flash configuration array */
+extern struct pdb_config *pdb_config_array;
+
+/* The number of elements in the pdb_config_array */
+#define PDB_CONFIG_ARRAY_LEN 128
+
+
+/*
+ * Print a struct pdb_config to the given BaseSequentialStream
+ */
+void pdb_config_print(BaseSequentialStream *chp, const struct pdb_config *cfg);
+
+/*
+ * Erase the flash page used for configuration
+ */
+void pdb_config_flash_erase(void);
+
+/*
+ * Write a configuration structure to flash, invalidating the previous
+ * configuration.  If necessary, the flash page is erased before writing the
+ * new structure.
+ */
+void pdb_config_flash_update(const struct pdb_config *cfg);
+
+/*
+ * Get the first valid configuration strucure.  If the flash page is empty,
+ * return NULL instead.
+ */
+struct pdb_config *pdb_config_flash_read(void);
+
+
+#endif /* PDB_STORAGE_H */

src/usbcfg.c

@@ -0,0 +1,352 @@
+/*
+ * PD Buddy - USB Power Delivery for everyone
+ * Copyright (C) 2017 Clayton G. Hobbs <clay@lakeserv.net>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+    ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#include "usbcfg.h"
+
+
+/* Virtual serial port over USB.*/
+SerialUSBDriver SDU1;
+
+/*
+ * Endpoints to be used for USBD1.
+ */
+#define USBD1_DATA_REQUEST_EP           1
+#define USBD1_DATA_AVAILABLE_EP         1
+#define USBD1_INTERRUPT_REQUEST_EP      2
+
+/*
+ * USB Device Descriptor.
+ */
+static const uint8_t vcom_device_descriptor_data[18] = {
+    USB_DESC_DEVICE       (0x0110,        /* bcdUSB (1.1).                    */
+            0x02,          /* bDeviceClass (CDC).              */
+            0x00,          /* bDeviceSubClass.                 */
+            0x00,          /* bDeviceProtocol.                 */
+            0x40,          /* bMaxPacketSize.                  */
+            0x1209,        /* idVendor (pid.codes).            */
+            0x0001,        /* idProduct.                       */
+            0x0200,        /* bcdDevice.                       */
+            1,             /* iManufacturer.                   */
+            2,             /* iProduct.                        */
+            3,             /* iSerialNumber.                   */
+            1)             /* bNumConfigurations.              */
+};
+
+/*
+ * Device Descriptor wrapper.
+ */
+static const USBDescriptor vcom_device_descriptor = {
+    sizeof vcom_device_descriptor_data,
+    vcom_device_descriptor_data
+};
+
+/* Configuration Descriptor tree for a CDC.*/
+static const uint8_t vcom_configuration_descriptor_data[67] = {
+    /* Configuration Descriptor.*/
+    USB_DESC_CONFIGURATION(67,            /* wTotalLength.                    */
+            0x02,          /* bNumInterfaces.                  */
+            0x01,          /* bConfigurationValue.             */
+            0,             /* iConfiguration.                  */
+            0xC0,          /* bmAttributes (self powered).     */
+            50),           /* bMaxPower (100mA).               */
+    /* Interface Descriptor.*/
+    USB_DESC_INTERFACE    (0x00,          /* bInterfaceNumber.                */
+            0x00,          /* bAlternateSetting.               */
+            0x01,          /* bNumEndpoints.                   */
+            0x02,          /* bInterfaceClass (Communications
+                              Interface Class, CDC section
+                              4.2).                            */
+            0x02,          /* bInterfaceSubClass (Abstract
+                              Control Model, CDC section 4.3).   */
+            0x01,          /* bInterfaceProtocol (AT commands,
+                              CDC section 4.4).                */
+            0),            /* iInterface.                      */
+    /* Header Functional Descriptor (CDC section 5.2.3).*/
+    USB_DESC_BYTE         (5),            /* bLength.                         */
+    USB_DESC_BYTE         (0x24),         /* bDescriptorType (CS_INTERFACE).  */
+    USB_DESC_BYTE         (0x00),         /* bDescriptorSubtype (Header
+                                             Functional Descriptor.           */
+    USB_DESC_BCD          (0x0110),       /* bcdCDC.                          */
+    /* Call Management Functional Descriptor. */
+    USB_DESC_BYTE         (5),            /* bFunctionLength.                 */
+    USB_DESC_BYTE         (0x24),         /* bDescriptorType (CS_INTERFACE).  */
+    USB_DESC_BYTE         (0x01),         /* bDescriptorSubtype (Call Management
+                                             Functional Descriptor).          */
+    USB_DESC_BYTE         (0x00),         /* bmCapabilities (D0+D1).          */
+    USB_DESC_BYTE         (0x01),         /* bDataInterface.                  */
+    /* ACM Functional Descriptor.*/
+    USB_DESC_BYTE         (4),            /* bFunctionLength.                 */
+    USB_DESC_BYTE         (0x24),         /* bDescriptorType (CS_INTERFACE).  */
+    USB_DESC_BYTE         (0x02),         /* bDescriptorSubtype (Abstract
+                                             Control Management Descriptor).  */
+    USB_DESC_BYTE         (0x02),         /* bmCapabilities.                  */
+    /* Union Functional Descriptor.*/
+    USB_DESC_BYTE         (5),            /* bFunctionLength.                 */
+    USB_DESC_BYTE         (0x24),         /* bDescriptorType (CS_INTERFACE).  */
+    USB_DESC_BYTE         (0x06),         /* bDescriptorSubtype (Union
+                                             Functional Descriptor).          */
+    USB_DESC_BYTE         (0x00),         /* bMasterInterface (Communication
+                                             Class Interface).                */
+    USB_DESC_BYTE         (0x01),         /* bSlaveInterface0 (Data Class
+                                             Interface).                      */
+    /* Endpoint 2 Descriptor.*/
+    USB_DESC_ENDPOINT     (USBD1_INTERRUPT_REQUEST_EP|0x80,
+            0x03,          /* bmAttributes (Interrupt).        */
+            0x0008,        /* wMaxPacketSize.                  */
+            0xFF),         /* bInterval.                       */
+    /* Interface Descriptor.*/
+    USB_DESC_INTERFACE    (0x01,          /* bInterfaceNumber.                */
+            0x00,          /* bAlternateSetting.               */
+            0x02,          /* bNumEndpoints.                   */
+            0x0A,          /* bInterfaceClass (Data Class
+                              Interface, CDC section 4.5).     */
+            0x00,          /* bInterfaceSubClass (CDC section
+                              4.6).                            */
+            0x00,          /* bInterfaceProtocol (CDC section
+                              4.7).                            */
+            0x00),         /* iInterface.                      */
+    /* Endpoint 3 Descriptor.*/
+    USB_DESC_ENDPOINT     (USBD1_DATA_AVAILABLE_EP,       /* bEndpointAddress.*/
+            0x02,          /* bmAttributes (Bulk).             */
+            0x0040,        /* wMaxPacketSize.                  */
+            0x00),         /* bInterval.                       */
+    /* Endpoint 1 Descriptor.*/
+    USB_DESC_ENDPOINT     (USBD1_DATA_REQUEST_EP|0x80,    /* bEndpointAddress.*/
+            0x02,          /* bmAttributes (Bulk).             */
+            0x0040,        /* wMaxPacketSize.                  */
+            0x00)          /* bInterval.                       */
+};
+
+/*
+ * Configuration Descriptor wrapper.
+ */
+static const USBDescriptor vcom_configuration_descriptor = {
+    sizeof vcom_configuration_descriptor_data,
+    vcom_configuration_descriptor_data
+};
+
+/*
+ * U.S. English language identifier.
+ */
+static const uint8_t vcom_string0[] = {
+    USB_DESC_BYTE(4),                     /* bLength.                         */
+    USB_DESC_BYTE(USB_DESCRIPTOR_STRING), /* bDescriptorType.                 */
+    USB_DESC_WORD(0x0409)                 /* wLANGID (U.S. English).          */
+};
+
+/*
+ * Vendor string.
+ */
+static const uint8_t vcom_string1[] = {
+    USB_DESC_BYTE(34),                    /* bLength.                         */
+    USB_DESC_BYTE(USB_DESCRIPTOR_STRING), /* bDescriptorType.                 */
+    'C', 0, 'l', 0, 'a', 0, 'y', 0, 't', 0, 'o', 0, 'n', 0, ' ', 0,
+    'G', 0, '.', 0, ' ', 0, 'H', 0, 'o', 0, 'b', 0, 'b', 0, 's', 0,
+};
+
+/*
+ * Device Description string.
+ */
+static const uint8_t vcom_string2[] = {
+    USB_DESC_BYTE(28),                    /* bLength.                         */
+    USB_DESC_BYTE(USB_DESCRIPTOR_STRING), /* bDescriptorType.                 */
+    'P', 0, 'D', 0, ' ', 0, 'B', 0, 'u', 0, 'd', 0, 'd', 0, 'y', 0,
+    ' ', 0, 'S', 0, 'i', 0, 'n', 0, 'k', 0
+};
+
+/*
+ * Serial Number string.
+ */
+static const uint8_t vcom_string3[] = {
+    USB_DESC_BYTE(8),                     /* bLength.                         */
+    USB_DESC_BYTE(USB_DESCRIPTOR_STRING), /* bDescriptorType.                 */
+    '0' + CH_KERNEL_MAJOR, 0,
+    '0' + CH_KERNEL_MINOR, 0,
+    '0' + CH_KERNEL_PATCH, 0
+};
+
+/*
+ * Strings wrappers array.
+ */
+static const USBDescriptor vcom_strings[] = {
+    {sizeof vcom_string0, vcom_string0},
+    {sizeof vcom_string1, vcom_string1},
+    {sizeof vcom_string2, vcom_string2},
+    {sizeof vcom_string3, vcom_string3}
+};
+
+/*
+ * Handles the GET_DESCRIPTOR callback. All required descriptors must be
+ * handled here.
+ */
+static const USBDescriptor *get_descriptor(USBDriver *usbp,
+        uint8_t dtype,
+        uint8_t dindex,
+        uint16_t lang) {
+
+    (void)usbp;
+    (void)lang;
+    switch (dtype) {
+        case USB_DESCRIPTOR_DEVICE:
+            return &vcom_device_descriptor;
+        case USB_DESCRIPTOR_CONFIGURATION:
+            return &vcom_configuration_descriptor;
+        case USB_DESCRIPTOR_STRING:
+            if (dindex < 4)
+                return &vcom_strings[dindex];
+    }
+    return NULL;
+}
+
+/**
+ * @brief   IN EP1 state.
+ */
+static USBInEndpointState ep1instate;
+
+/**
+ * @brief   OUT EP1 state.
+ */
+static USBOutEndpointState ep1outstate;
+
+/**
+ * @brief   EP1 initialization structure (both IN and OUT).
+ */
+static const USBEndpointConfig ep1config = {
+    USB_EP_MODE_TYPE_BULK,
+    NULL,
+    sduDataTransmitted,
+    sduDataReceived,
+    0x0040,
+    0x0040,
+    &ep1instate,
+    &ep1outstate,
+    1,
+    NULL
+};
+
+/**
+ * @brief   IN EP2 state.
+ */
+static USBInEndpointState ep2instate;
+
+/**
+ * @brief   EP2 initialization structure (IN only).
+ */
+static const USBEndpointConfig ep2config = {
+    USB_EP_MODE_TYPE_INTR,
+    NULL,
+    sduInterruptTransmitted,
+    NULL,
+    0x0010,
+    0x0000,
+    &ep2instate,
+    NULL,
+    1,
+    NULL
+};
+
+/*
+ * Handles the USB driver global events.
+ */
+static void usb_event(USBDriver *usbp, usbevent_t event) {
+    extern SerialUSBDriver SDU1;
+
+    switch (event) {
+        case USB_EVENT_RESET:
+            return;
+        case USB_EVENT_ADDRESS:
+            return;
+        case USB_EVENT_CONFIGURED:
+            chSysLockFromISR();
+
+            /* Enables the endpoints specified into the configuration.
+               Note, this callback is invoked from an ISR so I-Class functions
+               must be used.*/
+            usbInitEndpointI(usbp, USBD1_DATA_REQUEST_EP, &ep1config);
+            usbInitEndpointI(usbp, USBD1_INTERRUPT_REQUEST_EP, &ep2config);
+
+            /* Resetting the state of the CDC subsystem.*/
+            sduConfigureHookI(&SDU1);
+
+            chSysUnlockFromISR();
+            return;
+        case USB_EVENT_UNCONFIGURED:
+            return;
+        case USB_EVENT_SUSPEND:
+            chSysLockFromISR();
+
+            /* Disconnection event on suspend.*/
+            sduDisconnectI(&SDU1);
+
+            chSysUnlockFromISR();
+            return;
+        case USB_EVENT_WAKEUP:
+            return;
+        case USB_EVENT_STALLED:
+            return;
+    }
+    return;
+}
+
+/*
+ * Handles the USB driver global events.
+ */
+static void sof_handler(USBDriver *usbp) {
+
+    (void)usbp;
+
+    osalSysLockFromISR();
+    sduSOFHookI(&SDU1);
+    osalSysUnlockFromISR();
+}
+
+/*
+ * USB driver configuration.
+ */
+const USBConfig usbcfg = {
+    usb_event,
+    get_descriptor,
+    sduRequestsHook,
+    sof_handler
+};
+
+/*
+ * Serial over USB driver configuration.
+ */
+const SerialUSBConfig serusbcfg = {
+    &USBD1,
+    USBD1_DATA_REQUEST_EP,
+    USBD1_DATA_AVAILABLE_EP,
+    USBD1_INTERRUPT_REQUEST_EP
+};

src/usbcfg.h

@@ -0,0 +1,46 @@
+/*
+ * PD Buddy - USB Power Delivery for everyone
+ * Copyright (C) 2017 Clayton G. Hobbs <clay@lakeserv.net>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+    ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#ifndef PDB_USBCFG_H
+#define PDB_USBCFG_H
+
+#include <hal.h>
+
+
+extern const USBConfig usbcfg;
+extern const SerialUSBConfig serusbcfg;
+extern SerialUSBDriver SDU1;
+
+
+#endif  /* PDB_USBCFG_H */