Wrote a mostly-complete USB PD 2.0 implementation

There are still a few things that the standard says we Shall do and we
don't, but it Works For Me™.  I haven't implemented anything with
regards to GiveBack support, but that doesn't matter just yet.  Our
handling of VDMs isn't quite right either.  Anyway, it successfully
negotiates with so-called Split PDO power supplies, which is more than I
can say about some commercial products.

Makefile

@@ -10,7 +10,7 @@ endif
 
 # C specific options here (added to USE_OPT).
 ifeq ($(USE_COPT),)
-  USE_COPT = 
+  USE_COPT = -std=c11
 endif
 
 # C++ specific options here (added to USE_OPT).

src/device_policy_manager.c

@@ -0,0 +1,124 @@
+/*
+ * 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 "device_policy_manager.h"
+
+#include <stdint.h>
+
+#include <hal.h>
+
+#include "led.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; /* 20 V */
+static uint16_t dpm_desired_i = 225; /* 2.25 A */
+
+/* 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 number of PDOs */
+    uint8_t numobj = PD_NUMOBJ_GET(capabilities);
+
+    /* Make the LED blink to indicate ongoing power negotiations */
+    chEvtSignal(pdb_led_thread, PDB_EVT_LED_FAST_BLINK);
+
+    /* Get whether or not the power supply is constrained */
+    if (capabilities->obj[0] & PD_PDO_SRC_FIXED_UNCONSTRAINED) {
+        dpm_unconstrained_power = 1;
+    } else {
+        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;
+        }
+    }
+    /* Nothing matched, so get 5 V */
+    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(10)
+        | PD_RDO_FV_CURRENT_SET(10)
+        | PD_RDO_NO_USB_SUSPEND | PD_RDO_CAP_MISMATCH
+        | PD_RDO_OBJPOS_SET(1);
+    return false;
+}
+
+void pdb_dpm_get_sink_capability(union pd_msg *cap)
+{
+    /* If we want 5 V, we need to send only one PDO */
+    if (dpm_desired_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);
+    /* Otherwise, send two PDOs, one for 5 V and one for the desired power. */
+    } else {
+        /* Sink_Capabilities message */
+        cap->hdr = PD_MSGTYPE_SINK_CAPABILITIES | PD_DATAROLE_UFP
+            | PD_SPECREV_2_0 | PD_POWERROLE_SINK | PD_NUMOBJ(2);
+        /* First, vSafe5V.  100 mA, 5 V, and higher capability. */
+        cap->obj[0] = PD_PDO_TYPE_FIXED
+            | PD_PDO_SNK_FIXED_VOLTAGE_SET(100)
+            | 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);
+    }
+
+    /* Set the unconstrained power flag. */
+    if (dpm_unconstrained_power) {
+        cap->obj[0] |= PD_PDO_SNK_FIXED_UNCONSTRAINED;
+    }
+}
+
+void pdb_dpm_output_on(void)
+{
+    chEvtSignal(pdb_led_thread, PDB_EVT_LED_MEDIUM_BLINK_OFF);
+    palSetLine(LINE_OUT_CTRL);
+}
+
+void pdb_dpm_output_off(void)
+{
+    chEvtSignal(pdb_led_thread, PDB_EVT_LED_ON);
+    palClearLine(LINE_OUT_CTRL);
+}

src/device_policy_manager.h

@@ -0,0 +1,50 @@
+/*
+ * 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_DEVICE_POLICY_MANAGER_H
+#define PDB_DEVICE_POLICY_MANAGER_H
+
+#include <stdbool.h>
+
+#include "messages.h"
+
+
+/*
+ * Create a Request message based on the given Source_Capabilities message.
+ *
+ * Returns false if sufficient power is not available, true if it is.
+ */
+bool pdb_dpm_evaluate_capability(const union pd_msg *capabilities, union pd_msg *request);
+
+/*
+ * Create a Sink_Capabilities message for our current capabilities.
+ */
+void pdb_dpm_get_sink_capability(union pd_msg *cap);
+
+/*
+ * Turn on the power output, with LED indication.
+ */
+void pdb_dpm_output_on(void);
+
+/*
+ * Turn off the power output, with LED indication.
+ */
+void pdb_dpm_output_off(void);
+
+
+#endif /* PDB_DEVICE_POLICY_MANAGER_H */

src/fusb302b.c

@@ -0,0 +1,205 @@
+/*
+ * 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 "fusb302b.h"
+
+#include <ch.h>
+#include <hal.h>
+
+#include "pd.h"
+
+
+/*
+ * Read a single byte from the FUSB302B
+ */
+static uint8_t fusb_read_byte(uint8_t addr)
+{
+    uint8_t buf;
+    i2cMasterTransmit(&I2CD2, FUSB302B_ADDR, &addr, 1, &buf, 1);
+    return buf;
+}
+
+/*
+ * Read multiple bytes from the FUSB302B
+ */
+static void fusb_read_buf(uint8_t addr, uint8_t size, uint8_t *buf)
+{
+    i2cMasterTransmit(&I2CD2, FUSB302B_ADDR, &addr, 1, buf, size);
+}
+
+/*
+ * Write a single byte to the FUSB302B
+ */
+static void fusb_write_byte(uint8_t addr, uint8_t byte)
+{
+    uint8_t buf[2] = {addr, byte};
+    i2cMasterTransmit(&I2CD2, FUSB302B_ADDR, buf, 2, NULL, 0);
+}
+
+/*
+ * Write multiple bytes to the FUSB302B
+ */
+static void fusb_write_buf(uint8_t addr, uint8_t size, const uint8_t *buf)
+{
+    uint8_t txbuf[size + 1];
+
+    /* Prepare the transmit buffer */
+    txbuf[0] = addr;
+    for (int i = 0; i < size; i++) {
+        txbuf[i + 1] = buf[i];
+    }
+
+    i2cMasterTransmit(&I2CD2, FUSB302B_ADDR, txbuf, size + 1, NULL, 0);
+}
+
+void fusb_send_message(const union pd_msg *msg)
+{
+    /* Token sequences for the FUSB302B */
+    static uint8_t sop_seq[5] = {0x12, 0x12, 0x12, 0x13, 0x80};
+    static uint8_t eop_seq[4] = {0xFF, 0x14, 0xFE, 0xA1};
+
+    /* Take the I2C2 mutex now so there can't be a race condition on sop_seq */
+    i2cAcquireBus(&I2CD2);
+
+    /* Get the length of the message: a two-octet header plus NUMOBJ four-octet
+     * data objects */
+    uint8_t msg_len = 2 + 4 * PD_NUMOBJ_GET(msg);
+
+    /* Set the number of bytes to be transmitted in the packet */
+    sop_seq[4] = 0x80 | msg_len;
+
+    /* Write all three parts of the message to the TX FIFO */
+    fusb_write_buf(FUSB_FIFOS, 5, sop_seq);
+    fusb_write_buf(FUSB_FIFOS, msg_len, msg->bytes);
+    fusb_write_buf(FUSB_FIFOS, 4, eop_seq);
+
+    i2cReleaseBus(&I2CD2);
+}
+
+uint8_t fusb_read_message(union pd_msg *msg)
+{
+    uint8_t garbage[4];
+    uint8_t numobj;
+
+    i2cAcquireBus(&I2CD2);
+
+    /* If this isn't an SOP message, return error.
+     * Because of our configuration, we should be able to assume this means the
+     * buffer is empty, and not try to read past a non-SOP message. */
+    if ((fusb_read_byte(FUSB_FIFOS) & FUSB_FIFO_RX_TOKEN_BITS)
+            != FUSB_FIFO_RX_SOP) {
+        i2cReleaseBus(&I2CD2);
+        return 1;
+    }
+    /* Read the message header into msg */
+    fusb_read_buf(FUSB_FIFOS, 2, msg->bytes);
+    /* Get the number of data objects */
+    numobj = PD_NUMOBJ_GET(msg);
+    /* If there is at least one data object, read the data objects */
+    if (numobj > 0) {
+        fusb_read_buf(FUSB_FIFOS, numobj * 4, msg->bytes + 2);
+    }
+    /* Throw the CRC32 in the garbage, since the PHY already checked it. */
+    fusb_read_buf(FUSB_FIFOS, 4, garbage);
+
+    i2cReleaseBus(&I2CD2);
+    return 0;
+}
+
+void fusb_send_hardrst(void)
+{
+    i2cAcquireBus(&I2CD2);
+
+    /* Send a hard reset */
+    fusb_write_byte(FUSB_CONTROL3, 0x07 | FUSB_CONTROL3_SEND_HARD_RESET);
+
+    i2cReleaseBus(&I2CD2);
+}
+
+void fusb_setup(void)
+{
+    i2cAcquireBus(&I2CD2);
+
+    /* Fully reset the FUSB302B */
+    fusb_write_byte(FUSB_RESET, FUSB_RESET_SW_RES);
+
+    /* Turn on all power */
+    fusb_write_byte(FUSB_POWER, 0x0F);
+
+    /* Set interrupt masks */
+    fusb_write_byte(FUSB_MASK1, 0x00);
+    fusb_write_byte(FUSB_MASKA, 0x00);
+    fusb_write_byte(FUSB_MASKB, 0x00);
+    fusb_write_byte(FUSB_CONTROL0, 0x04);
+
+    /* Enable automatic retransmission */
+    fusb_write_byte(FUSB_CONTROL3, 0x07);
+
+    /* Flush the RX buffer */
+    fusb_write_byte(FUSB_CONTROL1, FUSB_CONTROL1_RX_FLUSH);
+
+    /* Measure CC1 */
+    fusb_write_byte(FUSB_SWITCHES0, 0x07);
+    chThdSleepMicroseconds(250);
+    uint8_t cc1;
+    cc1 = fusb_read_byte(FUSB_STATUS0) & FUSB_STATUS0_BC_LVL;
+
+    /* Measure CC2 */
+    fusb_write_byte(FUSB_SWITCHES0, 0x0B);
+    chThdSleepMicroseconds(250);
+    uint8_t cc2;
+    cc2 = fusb_read_byte(FUSB_STATUS0) & FUSB_STATUS0_BC_LVL;
+
+    /* Select the correct CC line for BMC signaling; also enable AUTO_CRC */
+    if (cc1 > cc2) {
+        fusb_write_byte(FUSB_SWITCHES1, 0x25);
+        fusb_write_byte(FUSB_SWITCHES0, 0x07);
+    } else {
+        fusb_write_byte(FUSB_SWITCHES1, 0x26);
+        fusb_write_byte(FUSB_SWITCHES0, 0x0B);
+    }
+
+    /* Reset the PD logic */
+    fusb_write_byte(FUSB_RESET, FUSB_RESET_PD_RESET);
+
+    i2cReleaseBus(&I2CD2);
+}
+
+void fusb_get_status(union fusb_status *status)
+{
+    i2cAcquireBus(&I2CD2);
+
+    /* Read the interrupt and status flags into status */
+    fusb_read_buf(FUSB_STATUS0A, 7, status->bytes);
+
+    i2cReleaseBus(&I2CD2);
+}
+
+void fusb_reset(void)
+{
+    i2cAcquireBus(&I2CD2);
+
+    /* Flush the TX buffer */
+    fusb_write_byte(FUSB_CONTROL0, 0x44);
+    /* Flush the RX buffer */
+    fusb_write_byte(FUSB_CONTROL1, FUSB_CONTROL1_RX_FLUSH);
+    /* Reset the PD logic */
+    fusb_write_byte(FUSB_RESET, FUSB_RESET_PD_RESET);
+
+    i2cReleaseBus(&I2CD2);
+}

src/fusb302b.h

@@ -0,0 +1,288 @@
+/*
+ * 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_FUSB302B_H
+#define PDB_FUSB302B_H
+
+#include <stdint.h>
+
+#include "messages.h"
+
+
+/* I2C address of the FUSB302B */
+#define FUSB302B_ADDR 0x22
+
+/* Device ID register */
+#define FUSB_DEVICE_ID 0x01
+#define FUSB_DEVICE_ID_VERSION_ID_SHIFT 4
+#define FUSB_DEVICE_ID_VERSION_ID (0xF << FUSB_DEVICE_ID_VERSION_ID_SHIFT)
+#define FUSB_DEVICE_ID_PRODUCT_ID_SHIFT 2
+#define FUSB_DEVICE_ID_PRODUCT_ID (0x3 << FUSB_DEVICE_ID_PRODUCT_ID_SHIFT)
+#define FUSB_DEVICE_ID_REVISION_ID_SHIFT 0
+#define FUSB_DEVICE_ID_REVISION_ID (0x3 << FUSB_DEVICE_ID_REVISION_ID_SHIFT)
+
+/* Switches0 register */
+#define FUSB_SWITCHES0 0x02
+#define FUSB_SWITCHES0_PU_EN2 (1 << 7)
+#define FUSB_SWITCHES0_PU_EN1 (1 << 6)
+#define FUSB_SWITCHES0_VCONN_CC2 (1 << 5)
+#define FUSB_SWITCHES0_VCONN_CC1 (1 << 4)
+#define FUSB_SWITCHES0_MEAS_CC2 (1 << 3)
+#define FUSB_SWITCHES0_MEAS_CC1 (1 << 2)
+#define FUSB_SWITCHES0_PDWN_2 (1 << 1)
+#define FUSB_SWITCHES0_PDWN_1 1
+
+/* Switches1 register */
+#define FUSB_SWITCHES1 0x03
+#define FUSB_SWITCHES1_POWERROLE (1 << 7)
+#define FUSB_SWITCHES1_SPECREV_SHIFT 5
+#define FUSB_SWITCHES1_SPECREV (0x3 << FUSB_SWITCHES1_SPECREV_SHIFT)
+#define FUSB_SWITCHES1_DATAROLE (1 << 4)
+#define FUSB_SWITCHES1_AUTO_CRC (1 << 2)
+#define FUSB_SWITCHES1_TXCC2 (1 << 1)
+#define FUSB_SWITCHES1_TXCC1 1
+
+/* Measure register */
+#define FUSB_MEASURE 0x04
+#define FUSB_MEASURE_MEAS_VBUS (1 << 6)
+#define FUSB_MEASURE_MDAC_SHIFT 0
+#define FUSB_MEASURE_MDAC (0x3F << FUSB_MEASURE_MDAC_SHIFT)
+
+/* Slice register */
+#define FUSB_SLICE 0x05
+#define FUSB_SLICE_SDAC_HYS_SHIFT 6
+#define FUSB_SLICE_SDAC_HYS (0x3 << FUSB_SLICE_SDAC_HYS_SHIFT)
+#define FUSB_SLICE_SDAC_SHIFT 0
+#define FUSB_SLICE_SDAC (0x3F << FUSB_SLICE_SDAC_SHIFT)
+
+/* Control0 register */
+#define FUSB_CONTROL0 0x06
+#define FUSB_CONTROL0_TX_FLUSH (1 << 6)
+#define FUSB_CONTROL0_INT_MASK (1 << 5)
+#define FUSB_CONTROL0_HOST_CUR_SHIFT 2
+#define FUSB_CONTROL0_HOST_CUR (0x3 << FUSB_CONTROL0_HOST_CUR_SHIFT)
+#define FUSB_CONTROL0_AUTO_PRE (1 << 1)
+#define FUSB_CONTROL0_TX_START 1
+
+/* Control1 register */
+#define FUSB_CONTROL1 0x07
+#define FUSB_CONTROL1_ENSOP2DB (1 << 6)
+#define FUSB_CONTROL1_ENSOP1DB (1 << 5)
+#define FUSB_CONTROL1_BIST_MODE2 (1 << 4)
+#define FUSB_CONTROL1_RX_FLUSH (1 << 2)
+#define FUSB_CONTROL1_ENSOP2 (1 << 1)
+#define FUSB_CONTROL1_ENSOP1 1
+
+/* Control2 register */
+#define FUSB_CONTROL2 0x08
+#define FUSB_CONTROL2_TOG_SAVE_PWR_SHIFT 6
+#define FUSB_CONTROL2_TOG_SAVE_PWR (0x3 << FUSB_CONTROL2_TOG_SAVE_PWR)
+#define FUSB_CONTROL2_TOG_RD_ONLY (1 << 5)
+#define FUSB_CONTROL2_WAKE_EN (1 << 3)
+#define FUSB_CONTROL2_MODE_SHIFT 1
+#define FUSB_CONTROL2_MODE (0x3 << FUSB_CONTROL2_MODE_SHIFT)
+#define FUSB_CONTROL2_TOGGLE 1
+
+/* Control3 register */
+#define FUSB_CONTROL3 0x09
+#define FUSB_CONTROL3_SEND_HARD_RESET (1 << 6)
+#define FUSB_CONTROL3_BIST_TMODE (1 << 5)
+#define FUSB_CONTROL3_AUTO_HARDRESET (1 << 4)
+#define FUSB_CONTROL3_AUTO_SOFTRESET (1 << 3)
+#define FUSB_CONTROL3_N_RETRIES_SHIFT 1
+#define FUSB_CONTROL3_N_RETRIES (0x3 << FUSB_CONTROL3_N_RETRIES_SHIFT)
+#define FUSB_CONTROL3_AUTO_RETRY 1
+
+/* Mask1 register */
+#define FUSB_MASK1 0x0A
+#define FUSB_MASK1_M_VBUSOK (1 << 7)
+#define FUSB_MASK1_M_ACTIVITY (1 << 6)
+#define FUSB_MASK1_M_COMP_CHNG (1 << 5)
+#define FUSB_MASK1_M_CRC_CHK (1 << 4)
+#define FUSB_MASK1_M_ALERT (1 << 3)
+#define FUSB_MASK1_M_WAKE (1 << 2)
+#define FUSB_MASK1_M_COLLISION (1 << 1)
+#define FUSB_MASK1_M_BC_LVL (1 << 0)
+
+/* Power register */
+#define FUSB_POWER 0x0B
+#define FUSB_POWER_PWR3 (1 << 3)
+#define FUSB_POWER_PWR2 (1 << 2)
+#define FUSB_POWER_PWR1 (1 << 1)
+#define FUSB_POWER_PWR0 1
+
+/* Reset register */
+#define FUSB_RESET 0x0C
+#define FUSB_RESET_PD_RESET (1 << 1)
+#define FUSB_RESET_SW_RES 1
+
+/* OCPreg register */
+#define FUSB_OCPREG 0x0D
+#define FUSB_OCPREG_OCP_RANGE (1 << 3)
+#define FUSB_OCPREG_OCP_CUR_SHIFT 0
+#define FUSB_OCPREG_OCP_CUR (0x7 << FUSB_OCPREG_OCP_CUR_SHIFT)
+
+/* Maska register */
+#define FUSB_MASKA 0x0E
+#define FUSB_MASKA_M_OCP_TEMP (1 << 7)
+#define FUSB_MASKA_M_TOGDONE (1 << 6)
+#define FUSB_MASKA_M_SOFTFAIL (1 << 5)
+#define FUSB_MASKA_M_RETRYFAIL (1 << 4)
+#define FUSB_MASKA_M_HARDSENT (1 << 3)
+#define FUSB_MASKA_M_TXSENT (1 << 2)
+#define FUSB_MASKA_M_SOFTRST (1 << 1)
+#define FUSB_MASKA_M_HARDRST 1
+
+/* Maskb register */
+#define FUSB_MASKB 0x0F
+#define FUSB_MASKB_M_GCRCSENT 1
+
+/* Control4 register */
+#define FUSB_CONTROL4 0x10
+#define FUSB_CONTROL4_TOG_EXIT_AUD 1
+
+/* Status0a register */
+#define FUSB_STATUS0A 0x3C
+#define FUSB_STATUS0A_SOFTFAIL (1 << 5)
+#define FUSB_STATUS0A_RETRYFAIL (1 << 4)
+#define FUSB_STATUS0A_POWER3 (1 << 3)
+#define FUSB_STATUS0A_POWER2 (1 << 2)
+#define FUSB_STATUS0A_SOFTRST (1 << 1)
+#define FUSB_STATUS0A_HARDRST 1
+
+/* Status1a register */
+#define FUSB_STATUS1A 0x3D
+#define FUSB_STATUS1A_TOGSS_SHIFT 3
+#define FUSB_STATUS1A_TOGSS (0x7 << FUSB_STATUS1A_TOGSS_SHIFT)
+#define FUSB_STATUS1A_RXSOP2DB (1 << 2)
+#define FUSB_STATUS1A_RXSOP1DB (1 << 1)
+#define FUSB_STATUS1A_RXSOP 1
+
+/* Interrupta register */
+#define FUSB_INTERRUPTA 0x3E
+#define FUSB_INTERRUPTA_I_OCP_TEMP (1 << 7)
+#define FUSB_INTERRUPTA_I_TOGDONE (1 << 6)
+#define FUSB_INTERRUPTA_I_SOFTFAIL (1 << 5)
+#define FUSB_INTERRUPTA_I_RETRYFAIL (1 << 4)
+#define FUSB_INTERRUPTA_I_HARDSENT (1 << 3)
+#define FUSB_INTERRUPTA_I_TXSENT (1 << 2)
+#define FUSB_INTERRUPTA_I_SOFTRST (1 << 1)
+#define FUSB_INTERRUPTA_I_HARDRST 1
+
+/* Interruptb register */
+#define FUSB_INTERRUPTB 0x3F
+#define FUSB_INTERRUPTB_I_GCRCSENT 1
+
+/* Status0 register */
+#define FUSB_STATUS0 0x40
+#define FUSB_STATUS0_VBUSOK (1 << 7)
+#define FUSB_STATUS0_ACTIVITY (1 << 6)
+#define FUSB_STATUS0_COMP (1 << 5)
+#define FUSB_STATUS0_CRC_CHK (1 << 4)
+#define FUSB_STATUS0_ALERT (1 << 3)
+#define FUSB_STATUS0_WAKE (1 << 2)
+#define FUSB_STATUS0_BC_LVL_SHIFT 0
+#define FUSB_STATUS0_BC_LVL (0x3 << FUSB_STATUS0_BC_LVL_SHIFT)
+
+/* Status1 register */
+#define FUSB_STATUS1 0x41
+#define FUSB_STATUS1_RXSOP2 (1 << 7)
+#define FUSB_STATUS1_RXSOP1 (1 << 6)
+#define FUSB_STATUS1_RX_EMPTY (1 << 5)
+#define FUSB_STATUS1_RX_FULL (1 << 4)
+#define FUSB_STATUS1_TX_EMPTY (1 << 3)
+#define FUSB_STATUS1_TX_FULL (1 << 2)
+#define FUSB_STATUS1_OVRTEMP (1 << 1)
+#define FUSB_STATUS1_OCP 1
+
+/* Interrupt register */
+#define FUSB_INTERRUPT 0x42
+#define FUSB_INTERRUPT_I_VBUSOK (1 << 7)
+#define FUSB_INTERRUPT_I_ACTIVITY (1 << 6)
+#define FUSB_INTERRUPT_I_COMP_CHNG (1 << 5)
+#define FUSB_INTERRUPT_I_CRC_CHK (1 << 4)
+#define FUSB_INTERRUPT_I_ALERT (1 << 3)
+#define FUSB_INTERRUPT_I_WAKE (1 << 2)
+#define FUSB_INTERRUPT_I_COLLISION (1 << 1)
+#define FUSB_INTERRUPT_I_BC_LVL 1
+
+/* FIFOs register */
+#define FUSB_FIFOS 0x43
+
+#define FUSB_FIFO_RX_TOKEN_BITS 0xE0
+#define FUSB_FIFO_RX_SOP 0xE0
+#define FUSB_FIFO_RX_SOP1 0xC0
+#define FUSB_FIFO_RX_SOP2 0xA0
+#define FUSB_FIFO_RX_SOP1DB 0x80
+#define FUSB_FIFO_RX_SOP2DB 0x60
+
+
+/*
+ * FUSB status union
+ *
+ * Provides a nicer structure than just an array of uint8_t for working with
+ * the FUSB302B status and interrupt flags.
+ */
+union fusb_status {
+    uint8_t bytes[7];
+    struct {
+        uint8_t status0a;
+        uint8_t status1a;
+        uint8_t interrupta;
+        uint8_t interruptb;
+        uint8_t status0;
+        uint8_t status1;
+        uint8_t interrupt;
+    };
+};
+
+
+/* FUSB functions */
+
+/*
+ * Send a USB Power Delivery message to the FUSB302B
+ */
+void fusb_send_message(const union pd_msg *msg);
+
+/*
+ * Read a USB Power Delivery message from the FUSB302B
+ */
+uint8_t fusb_read_message(union pd_msg *msg);
+
+/*
+ * Tell the FUSB302B to send a hard reset signal
+ */
+void fusb_send_hardrst(void);
+
+/*
+ * Read the FUSB302B status and interrupt flags into *status
+ */
+void fusb_get_status(union fusb_status *status);
+
+/*
+ * Initialization routine for the FUSB302B
+ */
+void fusb_setup(void);
+
+/*
+ * Reset the FUSB302B
+ */
+void fusb_reset(void);
+
+
+#endif /* PDB_FUSB302B_H */

src/hard_reset.c

@@ -0,0 +1,166 @@
+/*
+ * 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 "hard_reset.h"
+
+#include "priorities.h"
+#include "policy_engine.h"
+#include "protocol_rx.h"
+#include "protocol_tx.h"
+#include "fusb302b.h"
+#include "pd.h"
+
+
+thread_t *pdb_hardrst_thread;
+
+/*
+ * Hard Reset machine states
+ */
+enum hardrst_state {
+    PRLHRResetLayer,
+    PRLHRIndicateHardReset,
+    PRLHRRequestHardReset,
+    PRLHRWaitPHY,
+    PRLHRHardResetRequested,
+    PRLHRWaitPE,
+    PRLHRComplete
+};
+
+/*
+ * PRL_HR_Reset_Layer state
+ */
+static enum hardrst_state hardrst_reset_layer(void)
+{
+    /* First, wait for the signal to run a hard reset. */
+    eventmask_t evt = chEvtWaitAny(PDB_EVT_HARDRST_RESET
+            | PDB_EVT_HARDRST_I_HARDRST);
+
+    /* Reset the stored message IDs */
+    pdb_prlrx_messageid = 0;
+    pdb_prltx_messageidcounter = 0;
+
+    /* Reset the Protocol RX machine */
+    chEvtSignal(pdb_prlrx_thread, PDB_EVT_PRLRX_RESET);
+    chThdYield();
+
+    /* Reset the Protocol TX machine */
+    chEvtSignal(pdb_prltx_thread, PDB_EVT_PRLTX_RESET);
+    chThdYield();
+
+    /* Continue the process based on what event started the reset. */
+    if (evt & PDB_EVT_HARDRST_RESET) {
+        /* Policy Engine started the reset. */
+        return PRLHRRequestHardReset;
+    } else {
+        /* PHY started the reset */
+        return PRLHRIndicateHardReset;
+    }
+}
+
+static enum hardrst_state hardrst_indicate_hard_reset(void)
+{
+    /* Tell the PE that we're doing a hard reset */
+    chEvtSignal(pdb_pe_thread, PDB_EVT_PE_RESET);
+
+    return PRLHRWaitPE;
+}
+
+static enum hardrst_state hardrst_request_hard_reset(void)
+{
+    /* Tell the PHY to send a hard reset */
+    fusb_send_hardrst();
+
+    return PRLHRWaitPHY;
+}
+
+static enum hardrst_state hardrst_wait_phy(void)
+{
+    /* Wait for the PHY to tell us that it's done sending the hard reset */
+    chEvtWaitAnyTimeout(PDB_EVT_HARDRST_I_HARDSENT, PD_T_HARD_RESET_COMPLETE);
+
+    /* Move on no matter what made us stop waiting. */
+    return PRLHRHardResetRequested;
+}
+
+static enum hardrst_state hardrst_hard_reset_requested(void)
+{
+    /* Tell the PE that the hard reset was sent */
+    chEvtSignal(pdb_pe_thread, PDB_EVT_PE_HARD_SENT);
+
+    return PRLHRWaitPE;
+}
+
+static enum hardrst_state hardrst_wait_pe(void)
+{
+    /* Wait for the PE to tell us that it's done */
+    chEvtWaitAny(PDB_EVT_HARDRST_DONE);
+
+    return PRLHRComplete;
+}
+
+static enum hardrst_state hardrst_complete(void)
+{
+    /* I'm not aware of anything we have to tell the FUSB302B, so just finish
+     * the reset routine. */
+    return PRLHRResetLayer;
+}
+
+/*
+ * Hard Reset state machine thread
+ */
+static THD_WORKING_AREA(waHardReset, 128);
+static THD_FUNCTION(HardReset, arg) {
+    (void) arg;
+    enum hardrst_state state = PRLHRResetLayer;
+
+    while (true) {
+        switch (state) {
+            case PRLHRResetLayer:
+                state = hardrst_reset_layer();
+                break;
+            case PRLHRIndicateHardReset:
+                state = hardrst_indicate_hard_reset();
+                break;
+            case PRLHRRequestHardReset:
+                state = hardrst_request_hard_reset();
+                break;
+            case PRLHRWaitPHY:
+                state = hardrst_wait_phy();
+                break;
+            case PRLHRHardResetRequested:
+                state = hardrst_hard_reset_requested();
+                break;
+            case PRLHRWaitPE:
+                state = hardrst_wait_pe();
+                break;
+            case PRLHRComplete:
+                state = hardrst_complete();
+                break;
+            default:
+                /* This is an error.  It really shouldn't happen.  We might
+                 * want to handle it anyway, though. */
+                break;
+        }
+    }
+}
+
+void pdb_hardrst_run(void)
+{
+    pdb_hardrst_thread = chThdCreateStatic(waHardReset, sizeof(waHardReset),
+            PDB_PRIO_PRL, HardReset, NULL);
+}

src/hard_reset.h

@@ -0,0 +1,40 @@
+/*
+ * 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_HARD_RESET_H
+#define PDB_HARD_RESET_H
+
+#include <ch.h>
+
+
+/* Events for the Hard Reset thread */
+#define PDB_EVT_HARDRST_RESET EVENT_MASK(0)
+#define PDB_EVT_HARDRST_I_HARDRST EVENT_MASK(1)
+#define PDB_EVT_HARDRST_I_HARDSENT EVENT_MASK(2)
+#define PDB_EVT_HARDRST_DONE EVENT_MASK(3)
+
+/* The Hard Reset thread object */
+extern thread_t *pdb_hardrst_thread;
+
+/*
+ * Start the Hard Reset thread
+ */
+void pdb_hardrst_run(void);
+
+
+#endif /* PDB_HARD_RESET_H */

src/int_n.c

@@ -0,0 +1,82 @@
+/*
+ * 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 "int_n.h"
+
+#include <ch.h>
+#include <hal.h>
+
+#include "priorities.h"
+#include "fusb302b.h"
+#include "protocol_rx.h"
+#include "protocol_tx.h"
+#include "hard_reset.h"
+
+
+/*
+ * INT_N polling thread
+ */
+static THD_WORKING_AREA(waIntNPoll, 128);
+static THD_FUNCTION(IntNPoll, arg) {
+    (void) arg;
+
+    union fusb_status status;
+    eventmask_t events;
+
+    while (true) {
+        /* If the INT_N line is low */
+        if (palReadLine(LINE_INT_N) == PAL_LOW) {
+            /* Read the FUSB302B status and interrupt registers */
+            fusb_get_status(&status);
+
+            /* If the I_GCRCSENT flag is set, tell the Protocol RX thread */
+            if (status.interruptb & FUSB_INTERRUPTB_I_GCRCSENT) {
+                chEvtSignal(pdb_prlrx_thread, PDB_EVT_PRLRX_I_GCRCSENT);
+            }
+
+            /* If the I_TXSENT or I_RETRYFAIL flag is set, tell the Protocol TX
+             * thread */
+            events = 0;
+            if (status.interrupta & FUSB_INTERRUPTA_I_RETRYFAIL) {
+                events |= PDB_EVT_PRLTX_I_RETRYFAIL;
+            }
+            if (status.interrupta & FUSB_INTERRUPTA_I_TXSENT) {
+                events |= PDB_EVT_PRLTX_I_TXSENT;
+            }
+            chEvtSignal(pdb_prltx_thread, events);
+
+            /* If the I_HARDRST or I_HARDSENT flag is set, tell the Hard Reset
+             * thread */
+            events = 0;
+            if (status.interrupta & FUSB_INTERRUPTA_I_HARDRST) {
+                events |= PDB_EVT_HARDRST_I_HARDRST;
+            }
+            if (status.interrupta & FUSB_INTERRUPTA_I_HARDSENT) {
+                events |= PDB_EVT_HARDRST_I_HARDSENT;
+            }
+            chEvtSignal(pdb_hardrst_thread, events);
+        }
+        chThdSleepMilliseconds(1);
+    }
+}
+
+void pdb_int_n_run(void)
+{
+    chThdCreateStatic(waIntNPoll, sizeof(waIntNPoll), PDB_PRIO_PRL_INT_N,
+            IntNPoll, NULL);
+}

src/int_n.h

@@ -0,0 +1,29 @@
+/*
+ * 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_INT_N_H
+#define PDB_INT_N_H
+
+
+/*
+ * Start the INT_N polling thread
+ */
+void pdb_int_n_run(void);
+
+
+#endif /* PDB_INT_N_H */

src/led.c

@@ -0,0 +1,116 @@
+/*
+ * 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 "led.h"
+
+#include <hal.h>
+
+#include "priorities.h"
+
+/* Delays for blink modes */
+#define LED_FAST MS2ST(125)
+#define LED_MEDIUM MS2ST(250)
+#define LED_SLOW MS2ST(500)
+
+/* Number of blinks for medium blink off mode */
+#define LED_MEDIUM_BLINKS 3
+
+
+thread_t *pdb_led_thread;
+
+/*
+ * LED blinker thread.
+ */
+static THD_WORKING_AREA(waLED, 128);
+static THD_FUNCTION(LED, arg) {
+    (void) arg;
+    /* LED starts turned off */
+    eventmask_t state = PDB_EVT_LED_OFF;
+    /* The event just received */
+    eventmask_t newstate;
+    /* Timeout.  TIME_INFINITE for steady modes, other values for blinking
+     * modes. */
+    systime_t timeout = TIME_INFINITE;
+    /* Counter for blinking modes */
+    int i;
+
+    while (true) {
+        /* Wait for any event except the last one we saw */
+        newstate = chEvtWaitOneTimeout(ALL_EVENTS & ~state, timeout);
+        /* If we're changing state, reset the counter */
+        if (newstate != 0) {
+            /* Clear the events to make sure we don't get an unexpected state
+             * change.  As an example of such an unexpected state change, if we
+             * set the state to ON, then ON, then BLINK, the second ON wouldn't
+             * be seen until after we handled the BLINK event, causing us to
+             * end up in the ON state in the end. */
+            chEvtGetAndClearEvents(ALL_EVENTS);
+            state = newstate;
+            i = 0;
+        }
+
+        switch (state) {
+            case PDB_EVT_LED_OFF:
+                timeout = TIME_INFINITE;
+                palClearLine(LINE_LED);
+                break;
+            case PDB_EVT_LED_ON:
+                timeout = TIME_INFINITE;
+                palSetLine(LINE_LED);
+                break;
+            case PDB_EVT_LED_FAST_BLINK:
+                timeout = LED_FAST;
+                if (i == 0) {
+                    palSetLine(LINE_LED);
+                } else {
+                    palToggleLine(LINE_LED);
+                }
+                break;
+            case PDB_EVT_LED_MEDIUM_BLINK_OFF:
+                timeout = LED_MEDIUM;
+                if (i == 0) {
+                    palSetLine(LINE_LED);
+                } else if (i < (LED_MEDIUM_BLINKS * 2) - 1) {
+                    palToggleLine(LINE_LED);
+                } else {
+                    palClearLine(LINE_LED);
+                    timeout = TIME_INFINITE;
+                }
+                break;
+            case PDB_EVT_LED_SLOW_BLINK:
+                timeout = LED_SLOW;
+                if (i == 0) {
+                    palSetLine(LINE_LED);
+                } else {
+                    palToggleLine(LINE_LED);
+                }
+                break;
+            default:
+                break;
+        }
+
+        /* Increment the counter for the blinking modes */
+        i++;
+    }
+}
+
+void pdb_led_run(void)
+{
+    pdb_led_thread = chThdCreateStatic(waLED, sizeof(waLED), PDB_PRIO_LED, LED,
+            NULL);
+}

src/led.h

@@ -0,0 +1,41 @@
+/*
+ * 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_LED_H
+#define PDB_LED_H
+
+#include <ch.h>
+
+
+/* Events for the LED thread */
+#define PDB_EVT_LED_OFF EVENT_MASK(0)
+#define PDB_EVT_LED_ON EVENT_MASK(1)
+#define PDB_EVT_LED_FAST_BLINK EVENT_MASK(2)
+#define PDB_EVT_LED_MEDIUM_BLINK_OFF EVENT_MASK(3)
+#define PDB_EVT_LED_SLOW_BLINK EVENT_MASK(4)
+
+/* The LED thread object */
+extern thread_t *pdb_led_thread;
+
+/*
+ * Start the LED thread
+ */
+void pdb_led_run(void);
+
+
+#endif /* PDB_LED_H */

src/main.c

@@ -17,11 +17,11 @@
  */
 
 /*
-    ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio
+   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
+   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
 
@@ -32,23 +32,66 @@
     limitations under the License.
 */
 
-#include "ch.h"
-#include "hal.h"
+#include <ch.h>
+#include <hal.h>
+
+#include "priorities.h"
+#include "led.h"
+#include "policy_engine.h"
+#include "protocol_tx.h"
+#include "protocol_rx.h"
+#include "hard_reset.h"
+#include "int_n.h"
+#include "fusb302b.h"
+#include "messages.h"
 
 /*
- * LED blinker thread, times are in milliseconds.
+ * I2C configuration object.
+ * I2C2_TIMINGR: 1000 kHz with I2CCLK = 48 MHz, rise time = 100 ns,
+ *               fall time = 10 ns (0x00700818)
  */
-static THD_WORKING_AREA(waThread1, 128);
-static THD_FUNCTION(Thread1, arg) {
-
-  (void)arg;
-//  chRegSetThreadName("blinker1");
-  while (true) {
-    palClearLine(LINE_LED);
-    chThdSleepMilliseconds(125);
-    palSetLine(LINE_LED);
-    chThdSleepMilliseconds(125);
-  }
+static const I2CConfig i2c2config = {
+    0x00700818,
+    0,
+    0
+};
+
+static void setup(void)
+{
+    chEvtSignal(pdb_led_thread, PDB_EVT_LED_SLOW_BLINK);
+
+    /* TODO: implement the configuration mode */
+
+    while (true) {
+        chThdSleepMilliseconds(1000);
+    }
+}
+
+static void pd_buddy(void)
+{
+    chEvtSignal(pdb_led_thread, PDB_EVT_LED_FAST_BLINK);
+
+    /* Start I2C2 to make communication with the PHY possible */
+    i2cStart(&I2CD2, &i2c2config);
+
+    /* Initialize the FUSB302B */
+    fusb_setup();
+
+    /* Create the policy engine thread. */
+    pdb_pe_run();
+
+    /* Create the protocol layer threads. */
+    pdb_prlrx_run();
+    pdb_prltx_run();
+    pdb_hardrst_run();
+
+    /* Create the INT_N thread. */
+    pdb_int_n_run();
+
+    /* Wait, letting all the other threads do their work. */
+    while (true) {
+        chThdSleepMilliseconds(1000);
+    }
 }
 
 /*
@@ -56,28 +99,28 @@ static THD_FUNCTION(Thread1, arg) {
  */
 int main(void) {
 
-  /*
-   * System initializations.
-   * - HAL initialization, this also initializes the configured device drivers
-   *   and performs the board-specific initializations.
-   * - Kernel initialization, the main() function becomes a thread and the
-   *   RTOS is active.
-   */
-  halInit();
-  chSysInit();
-
-  /*
-   * Creates the blinker thread.
-   */
-  chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
-
-  /*
-   * Normal main() thread activity, in this demo it does nothing except
-   * sleeping in a loop and check the button state, when the button is
-   * pressed the test procedure is launched with output on the serial
-   * driver 1.
-   */
-  while (true) {
-    chThdSleepMilliseconds(500);
-  }
+    /*
+     * System initializations.
+     * - HAL initialization, this also initializes the configured device drivers
+     *   and performs the board-specific initializations.
+     * - Kernel initialization, the main() function becomes a thread and the
+     *   RTOS is active.
+     */
+    halInit();
+    chSysInit();
+
+    /* Set up the free messages mailbox */
+    pdb_msg_pool_init();
+
+    /* Create the LED thread. */
+    pdb_led_run();
+
+    /* Decide what mode to enter by the state of the button */
+    if (palReadLine(LINE_BUTTON) == PAL_HIGH) {
+        /* Button pressed -> setup mode */
+        setup();
+    } else {
+        /* Button unpressed -> deliver power, buddy! */
+        pd_buddy();
+    }
 }

src/messages.c

@@ -0,0 +1,36 @@
+/*
+ * 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 "messages.h"
+
+
+/* The messages that will be available for threads to pass each other */
+static union pd_msg pd_messages[PDB_MSG_POOL_SIZE] __attribute__((aligned(sizeof(stkalign_t))));
+
+/* The pool of available messages */
+memory_pool_t pdb_msg_pool;
+
+
+void pdb_msg_pool_init(void)
+{
+    /* Initialize the pool itself */
+    chPoolObjectInit(&pdb_msg_pool, sizeof (union pd_msg), NULL);
+
+    /* Fill the pool with the available buffers */
+    chPoolLoadArray(&pdb_msg_pool, pd_messages, PDB_MSG_POOL_SIZE);
+}

src/messages.h

@@ -0,0 +1,60 @@
+/*
+ * 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_MESSAGES_H
+#define PDB_MESSAGES_H
+
+#include <stdint.h>
+
+#include <ch.h>
+
+
+/*
+ * PD message union
+ *
+ * This can be safely read from or written to in either form without any
+ * transformations because everything in the system is little-endian.
+ *
+ * Two bytes of padding are required at the start to prevent problems due to
+ * alignment.  Specifically, without the padding, &obj[0] != &bytes[2], making
+ * the statement in the previous paragraph invalid.
+ */
+union pd_msg {
+    struct {
+        uint8_t _pad1[2];
+        uint8_t bytes[30];
+    } __attribute__((packed));
+    struct {
+        uint8_t _pad2[2];
+        uint16_t hdr;
+        uint32_t obj[7];
+    } __attribute__((packed));
+};
+
+/* Available messages */
+#define PDB_MSG_POOL_SIZE 4
+
+extern memory_pool_t pdb_msg_pool;
+
+/*
+ * Initialize the msg_pool
+ */
+void pdb_msg_pool_init(void);
+
+
+#endif /* PDB_MESSAGES_H */

src/pd.h

@@ -0,0 +1,219 @@
+/*
+ * 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_PD_H
+#define PDB_PD_H
+
+#include <ch.h>
+
+
+/*
+ * Macros for working with USB Power Delivery messages.
+ *
+ * This file is mostly written from the PD Rev. 2.0 spec, but the header is
+ * written from the Rev. 3.0 spec.
+ */
+
+/*
+ * PD Header
+ */
+#define PD_HDR_MSGTYPE_SHIFT 0
+#define PD_HDR_MSGTYPE (0x1F << PD_HDR_MSGTYPE_SHIFT)
+#define PD_HDR_DATAROLE_SHIFT 5
+#define PD_HDR_DATAROLE (0x1 << PD_HDR_DATAROLE_SHIFT)
+#define PD_HDR_SPECREV_SHIFT 6
+#define PD_HDR_SPECREV (0x3 << PD_HDR_SPECREV_SHIFT)
+#define PD_HDR_POWERROLE_SHIFT 8
+#define PD_HDR_POWERROLE (1 << PD_HDR_POWERROLE_SHIFT)
+#define PD_HDR_MESSAGEID_SHIFT 9
+#define PD_HDR_MESSAGEID (0x7 << PD_HDR_MESSAGEID_SHIFT)
+#define PD_HDR_NUMOBJ_SHIFT 12
+#define PD_HDR_NUMOBJ (0x7 << PD_HDR_NUMOBJ_SHIFT)
+#define PD_HDR_EXT (1 << 15)
+
+/* Message types */
+#define PD_MSGTYPE_GET(msg) (((msg)->hdr & PD_HDR_MSGTYPE) >> PD_HDR_MSGTYPE_SHIFT)
+/* Control Message */
+#define PD_MSGTYPE_GOODCRC 0x01
+#define PD_MSGTYPE_GOTOMIN 0x02
+#define PD_MSGTYPE_ACCEPT 0x03
+#define PD_MSGTYPE_REJECT 0x04
+#define PD_MSGTYPE_PING 0x05
+#define PD_MSGTYPE_PS_RDY 0x06
+#define PD_MSGTYPE_GET_SOURCE_CAP 0x07
+#define PD_MSGTYPE_GET_SINK_CAP 0x08
+#define PD_MSGTYPE_DR_SWAP 0x09
+#define PD_MSGTYPE_PR_SWAP 0x0A
+#define PD_MSGTYPE_VCONN_SWAP 0x0B
+#define PD_MSGTYPE_WAIT 0x0C
+#define PD_MSGTYPE_SOFT_RESET 0x0D
+#define PD_MSGTYPE_NOT_SUPPORTED 0x10
+#define PD_MSGTYPE_GET_SOURCE_CAP_EXTENDED 0x11
+#define PD_MSGTYPE_GET_STATUS 0x12
+#define PD_MSGTYPE_FR_SWAP 0x13
+#define PD_MSGTYPE_GET_PPS_STATUS 0x14
+#define PD_MSGTYPE_GET_COUNTRY_CODES 0x15
+/* Data Message */
+#define PD_MSGTYPE_SOURCE_CAPABILITIES 0x01
+#define PD_MSGTYPE_REQUEST 0x02
+#define PD_MSGTYPE_BIST 0x03
+#define PD_MSGTYPE_SINK_CAPABILITIES 0x04
+#define PD_MSGTYPE_BATTERY_STATUS 0x05
+#define PD_MSGTYPE_ALERT 0x06
+#define PD_MSGTYPE_GET_COUNTRY_INFO 0x07
+#define PD_MSGTYPE_VENDOR_DEFINED 0x0F
+/* Extended Message */
+#define PD_MSGTYPE_SOURCE_CAPABILITIES_EXTENDED 0x01
+#define PD_MSGTYPE_STATUS 0x02
+#define PD_MSGTYPE_GET_BATTERY_CAP 0x03
+#define PD_MSGTYPE_GET_BATTERY_STATUS 0x04
+#define PD_MSGTYPE_BATTERY_CAPABILITIES 0x05
+#define PD_MSGTYPE_GET_MANUFACTURER_INFO 0x06
+#define PD_MSGTYPE_MANUFACTURER_INFO 0x07
+#define PD_MSGTYPE_SECURITY_REQUEST 0x08
+#define PD_MSGTYPE_SECURITY_RESPONSE 0x09
+#define PD_MSGTYPE_FIRMWARE_UPDATE_REQUEST 0x0A
+#define PD_MSGTYPE_FIRMWARE_UPDATE_RESPONSE 0x0B
+#define PD_MSGTYPE_PPS_STATUS 0x0C
+#define PD_MSGTYPE_COUNTRY_INFO 0x0D
+#define PD_MSGTYPE_COUNTRY_CODES 0x0E
+
+/* Data roles */
+#define PD_DATAROLE_UFP (0x0 << PD_HDR_DATAROLE_SHIFT)
+#define PD_DATAROLE_DFP (0x1 << PD_HDR_DATAROLE_SHIFT)
+
+/* Specification revisions */
+#define PD_SPECREV_1_0 (0x0 << PD_HDR_SPECREV_SHIFT)
+#define PD_SPECREV_2_0 (0x1 << PD_HDR_SPECREV_SHIFT)
+#define PD_SPECREV_3_0 (0x2 << PD_HDR_SPECREV_SHIFT)
+
+/* Port power roles */
+#define PD_POWERROLE_SINK (0x0 << PD_HDR_POWERROLE_SHIFT)
+#define PD_POWERROLE_SOURCE (0x1 << PD_HDR_POWERROLE_SHIFT)
+
+/* Message ID */
+#define PD_MESSAGEID_GET(msg) (((msg)->hdr & PD_HDR_MESSAGEID) >> PD_HDR_MESSAGEID_SHIFT)
+
+/* Number of data objects */
+#define PD_NUMOBJ(n) (((n) << PD_HDR_NUMOBJ_SHIFT) & PD_HDR_NUMOBJ)
+#define PD_NUMOBJ_GET(msg) (((msg)->hdr & PD_HDR_NUMOBJ) >> PD_HDR_NUMOBJ_SHIFT)
+
+
+/*
+ * PD Power Data Object
+ */
+#define PD_PDO_TYPE_SHIFT 30
+#define PD_PDO_TYPE (0x3 << PD_PDO_TYPE_SHIFT)
+
+/* PDO types */
+#define PD_PDO_TYPE_FIXED (0x0 << PD_PDO_TYPE_SHIFT)
+#define PD_PDO_TYPE_BATTERY (0x1 << PD_PDO_TYPE_SHIFT)
+#define PD_PDO_TYPE_VARIABLE (0x2 << PD_PDO_TYPE_SHIFT)
+
+/* PD Source Fixed PDO */
+#define PD_PDO_SRC_FIXED_DUAL_ROLE_PWR_SHIFT 29
+#define PD_PDO_SRC_FIXED_DUAL_ROLE_PWR (1 << PD_PDO_SRC_FIXED_DUAL_ROLE_PWR_SHIFT)
+#define PD_PDO_SRC_FIXED_USB_SUSPEND_SHIFT 28
+#define PD_PDO_SRC_FIXED_USB_SUSPEND (1 << PD_PDO_SRC_FIXED_USB_SUSPEND_SHIFT)
+#define PD_PDO_SRC_FIXED_UNCONSTRAINED_SHIFT 27
+#define PD_PDO_SRC_FIXED_UNCONSTRAINED (1 << PD_PDO_SRC_FIXED_UNCONSTRAINED_SHIFT)
+#define PD_PDO_SRC_FIXED_USB_COMMS_SHIFT 26
+#define PD_PDO_SRC_FIXED_USB_COMMS (1 << PD_PDO_SRC_FIXED_USB_COMMS_SHIFT)
+#define PD_PDO_SRC_FIXED_DUAL_ROLE_DATA_SHIFT 25
+#define PD_PDO_SRC_FIXED_DUAL_ROLE_DATA (1 << PD_PDO_SRC_FIXED_DUAL_ROLE_DATA_SHIFT)
+#define PD_PDO_SRC_FIXED_PEAK_CURRENT_SHIFT 20
+#define PD_PDO_SRC_FIXED_PEAK_CURRENT (0x3 << PD_PDO_SRC_FIXED_PEAK_CURRENT_SHIFT)
+#define PD_PDO_SRC_FIXED_VOLTAGE_SHIFT 10
+#define PD_PDO_SRC_FIXED_VOLTAGE (0x3FF << PD_PDO_SRC_FIXED_VOLTAGE_SHIFT)
+#define PD_PDO_SRC_FIXED_CURRENT_SHIFT 0
+#define PD_PDO_SRC_FIXED_CURRENT (0x3FF << PD_PDO_SRC_FIXED_CURRENT_SHIFT)
+
+/* PD Source Fixed PDO current */
+#define PD_PDO_SRC_FIXED_CURRENT_GET(msg, i) (((msg)->obj[(i)] & PD_PDO_SRC_FIXED_CURRENT) >> PD_PDO_SRC_FIXED_CURRENT_SHIFT)
+
+/* PD Source Fixed PDO voltage */
+#define PD_PDO_SRC_FIXED_VOLTAGE_GET(msg, i) (((msg)->obj[(i)] & PD_PDO_SRC_FIXED_VOLTAGE) >> PD_PDO_SRC_FIXED_VOLTAGE_SHIFT)
+
+/* TODO: other types of source PDO */
+
+/* PD Sink Fixed PDO */
+#define PD_PDO_SNK_FIXED_DUAL_ROLE_PWR_SHIFT 29
+#define PD_PDO_SNK_FIXED_DUAL_ROLE_PWR (1 << PD_PDO_SNK_FIXED_DUAL_ROLE_PWR_SHIFT)
+#define PD_PDO_SNK_FIXED_HIGHER_CAP_SHIFT 28
+#define PD_PDO_SNK_FIXED_HIGHER_CAP (1 << PD_PDO_SNK_FIXED_HIGHER_CAP_SHIFT)
+#define PD_PDO_SNK_FIXED_UNCONSTRAINED_SHIFT 27
+#define PD_PDO_SNK_FIXED_UNCONSTRAINED (1 << PD_PDO_SNK_FIXED_UNCONSTRAINED_SHIFT)
+#define PD_PDO_SNK_FIXED_USB_COMMS_SHIFT 26
+#define PD_PDO_SNK_FIXED_USB_COMMS (1 << PD_PDO_SNK_FIXED_USB_COMMS_SHIFT)
+#define PD_PDO_SNK_FIXED_DUAL_ROLE_DATA_SHIFT 25
+#define PD_PDO_SNK_FIXED_DUAL_ROLE_DATA (1 << PD_PDO_SNK_FIXED_DUAL_ROLE_DATA_SHIFT)
+#define PD_PDO_SNK_FIXED_VOLTAGE_SHIFT 10
+#define PD_PDO_SNK_FIXED_VOLTAGE (0x3FF << PD_PDO_SNK_FIXED_VOLTAGE_SHIFT)
+#define PD_PDO_SNK_FIXED_CURRENT_SHIFT 0
+#define PD_PDO_SNK_FIXED_CURRENT (0x3FF << PD_PDO_SNK_FIXED_CURRENT_SHIFT)
+
+/* PD Sink Fixed PDO current */
+#define PD_PDO_SNK_FIXED_CURRENT_SET(i) (((i) << PD_PDO_SNK_FIXED_CURRENT_SHIFT) & PD_PDO_SNK_FIXED_CURRENT)
+
+/* PD Sink Fixed PDO voltage */
+#define PD_PDO_SNK_FIXED_VOLTAGE_SET(v) (((v) << PD_PDO_SNK_FIXED_VOLTAGE_SHIFT) & PD_PDO_SNK_FIXED_VOLTAGE)
+
+/* TODO: other types of sink PDO */
+
+
+/*
+ * PD Request Data Object
+ */
+#define PD_RDO_OBJPOS_SHIFT 28
+#define PD_RDO_OBJPOS (0x7 << PD_RDO_OBJPOS_SHIFT)
+#define PD_RDO_GIVEBACK_SHIFT 27
+#define PD_RDO_GIVEBACK (1 << PD_RDO_GIVEBACK_SHIFT)
+#define PD_RDO_CAP_MISMATCH_SHIFT 26
+#define PD_RDO_CAP_MISMATCH (1 << PD_RDO_CAP_MISMATCH_SHIFT)
+#define PD_RDO_USB_COMMS_SHIFT 25
+#define PD_RDO_USB_COMMS (1 << PD_RDO_USB_COMMS_SHIFT)
+#define PD_RDO_NO_USB_SUSPEND_SHIFT 24
+#define PD_RDO_NO_USB_SUSPEND (1 << PD_RDO_NO_USB_SUSPEND_SHIFT)
+
+#define PD_RDO_OBJPOS_SET(i) (((i) << PD_RDO_OBJPOS_SHIFT) & PD_RDO_OBJPOS)
+
+/* Fixed and Variable RDO, no giveback support */
+#define PD_RDO_FV_CURRENT_SHIFT 10
+#define PD_RDO_FV_CURRENT (0x3FF << PD_RDO_FV_CURRENT_SHIFT)
+#define PD_RDO_FV_MAX_CURRENT_SHIFT 0
+#define PD_RDO_FV_MAX_CURRENT (0x3FF << PD_RDO_FV_MAX_CURRENT_SHIFT)
+
+#define PD_RDO_FV_CURRENT_SET(i) (((i) << PD_RDO_FV_CURRENT_SHIFT) & PD_RDO_FV_CURRENT)
+#define PD_RDO_FV_MAX_CURRENT_SET(i) (((i) << PD_RDO_FV_MAX_CURRENT_SHIFT) & PD_RDO_FV_MAX_CURRENT)
+
+/* TODO: other types of RDO */
+
+
+/*
+ * Time values
+ *
+ * Where a range is specified, the middle of the range (rounded down to the
+ * nearest millisecond) is used.
+ */
+#define PD_T_HARD_RESET_COMPLETE MS2ST(4)
+#define PD_T_PS_TRANSITION MS2ST(500)
+#define PD_T_SENDER_RESPONSE MS2ST(27)
+#define PD_T_TYPEC_SINK_WAIT_CAP MS2ST(465)
+
+
+#endif /* PDB_PD_H */

src/policy_engine.c

@@ -0,0 +1,523 @@
+/*
+ * 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 "policy_engine.h"
+
+#include "messages.h"
+#include "priorities.h"
+#include "device_policy_manager.h"
+#include "protocol_tx.h"
+#include "hard_reset.h"
+#include "pd.h"
+
+
+thread_t *pdb_pe_thread;
+
+enum policy_engine_state {
+    PESinkStartup,
+    PESinkDiscovery,
+    PESinkWaitCap,
+    PESinkEvalCap,
+    PESinkSelectCap,
+    PESinkTransitionSink,
+    PESinkReady,
+    PESinkGetSourceCap,
+    PESinkGiveSinkCap,
+    PESinkHardReset,
+    PESinkTransitionDefault,
+    PESinkSoftReset,
+    PESinkSendSoftReset,
+    PESinkSendReject
+};
+
+/* The received message we're currently working with */
+static union pd_msg *policy_engine_message = NULL;
+/* Whether or not the source capabilities match our required power */
+static bool capability_match = false;
+/* Policy Engine thread mailbox */
+static msg_t pdb_pe_mailbox_queue[PDB_MSG_POOL_SIZE];
+mailbox_t pdb_pe_mailbox;
+
+static enum policy_engine_state pe_sink_startup(void)
+{
+    /* No need to reset the protocol layer here.  There are two ways into this
+     * state: startup and exiting hard reset.  On startup, the protocol layer
+     * is reset by the startup procedure.  When exiting hard reset, the
+     * protocol layer is reset by the hard reset state machine.  Since it's
+     * already done somewhere else, there's no need to do it again here. */
+
+    return PESinkDiscovery;
+}
+
+static enum policy_engine_state pe_sink_discovery(void)
+{
+    /* Wait for VBUS.  Since it's our only power source, we already know that
+     * we have it, so just move on. */
+
+    return PESinkWaitCap;
+}
+
+static enum policy_engine_state pe_sink_wait_cap(void)
+{
+    /* Fetch a message from the protocol layer */
+    eventmask_t evt = chEvtWaitAnyTimeout(PDB_EVT_PE_MSG_RX, PD_T_TYPEC_SINK_WAIT_CAP);
+    /* If we timed out waiting for Source_Capabilities, send a hard reset */
+    if (evt == 0) {
+        return PESinkHardReset;
+    }
+
+    /* Get the message */
+    if (chMBFetch(&pdb_pe_mailbox, (msg_t *) &policy_engine_message, TIME_IMMEDIATE) == MSG_OK) {
+        /* If we got a Source_Capabilities message, read it. */
+        if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SOURCE_CAPABILITIES
+                && PD_NUMOBJ_GET(policy_engine_message) > 0) {
+            return PESinkEvalCap;
+        /* If the message was a Soft_Reset, do the soft reset procedure */
+        } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SOFT_RESET
+                && PD_NUMOBJ_GET(policy_engine_message) == 0) {
+            chPoolFree(&pdb_msg_pool, policy_engine_message);
+            policy_engine_message = NULL;
+            return PESinkSoftReset;
+        /* If we got an unexpected message, reset */
+        } else {
+            /* Free the received message */
+            chPoolFree(&pdb_msg_pool, policy_engine_message);
+            return PESinkHardReset;
+        }
+    }
+
+    /* If we failed to get a message, send a hard reset */
+    return PESinkHardReset;
+}
+
+static enum policy_engine_state pe_sink_eval_cap(void)
+{
+    /* Get a message object */
+    union pd_msg *request = chPoolAlloc(&pdb_msg_pool);
+    /* Ask the DPM what to request */
+    capability_match = pdb_dpm_evaluate_capability(policy_engine_message, request);
+    /* Free the Source_Capabilities message */
+    chPoolFree(&pdb_msg_pool, policy_engine_message);
+    /* Put the request into policy_engine_message */
+    policy_engine_message = request;
+
+    return PESinkSelectCap;
+}
+
+static enum policy_engine_state pe_sink_select_cap(void)
+{
+    /* Transmit the request */
+    chMBPost(&pdb_prltx_mailbox, (msg_t) policy_engine_message, TIME_IMMEDIATE);
+    chEvtSignal(pdb_prltx_thread, PDB_EVT_PRLTX_MSG_TX);
+    eventmask_t evt = chEvtWaitAny(PDB_EVT_PE_TX_DONE | PDB_EVT_PE_TX_ERR);
+    /* Free the sent message */
+    chPoolFree(&pdb_msg_pool, policy_engine_message);
+    policy_engine_message = NULL;
+    /* If the message transmission failed, send a hard reset */
+    if ((evt & PDB_EVT_PE_TX_DONE) == 0) {
+        return PESinkHardReset;
+    }
+
+    /* Wait for a response */
+    evt = chEvtWaitAnyTimeout(PDB_EVT_PE_MSG_RX, PD_T_SENDER_RESPONSE);
+    /* If we didn't get a response before the timeout, send a hard reset */
+    if (evt == 0) {
+        return PESinkHardReset;
+    }
+
+    /* Get the response message */
+    if (chMBFetch(&pdb_pe_mailbox, (msg_t *) &policy_engine_message, TIME_IMMEDIATE) == MSG_OK) {
+        /* If the source accepted our request, wait for the new power */
+        if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_ACCEPT
+                && PD_NUMOBJ_GET(policy_engine_message) == 0) {
+            chPoolFree(&pdb_msg_pool, policy_engine_message);
+            policy_engine_message = NULL;
+            return PESinkTransitionSink;
+        /* If the message was a Soft_Reset, do the soft reset procedure */
+        } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SOFT_RESET
+                && PD_NUMOBJ_GET(policy_engine_message) == 0) {
+            chPoolFree(&pdb_msg_pool, policy_engine_message);
+            policy_engine_message = NULL;
+            return PESinkSoftReset;
+        /* TODO: Wait and Reject messages should be recognized here */
+        } else {
+            return PESinkSendSoftReset;
+        }
+    }
+    return PESinkHardReset;
+}
+
+static enum policy_engine_state pe_sink_transition_sink(void)
+{
+    /* Wait for the PS_RDY message */
+    eventmask_t evt = chEvtWaitAnyTimeout(PDB_EVT_PE_MSG_RX, PD_T_PS_TRANSITION);
+    /* If no message was received, send a hard reset */
+    if (evt == 0) {
+        return PESinkHardReset;
+    }
+
+    /* If we received a message, read it */
+    if (chMBFetch(&pdb_pe_mailbox, (msg_t *) &policy_engine_message, TIME_IMMEDIATE) == MSG_OK) {
+        /* If we got a PS_RDY, handle it */
+        if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_PS_RDY
+                && PD_NUMOBJ_GET(policy_engine_message) == 0) {
+            /* Set the output appropriately */
+            if (capability_match) {
+                pdb_dpm_output_on();
+            } else {
+                pdb_dpm_output_off();
+            }
+
+            chPoolFree(&pdb_msg_pool, policy_engine_message);
+            policy_engine_message = NULL;
+            return PESinkReady;
+        /* If there was a protocol error, send a hard reset */
+        } else {
+            /* Turn off the power output before this hard reset to make sure we
+             * don't supply an incorrect voltage to the device we're powering.
+             */
+            pdb_dpm_output_off();
+
+            chPoolFree(&pdb_msg_pool, policy_engine_message);
+            policy_engine_message = NULL;
+            return PESinkHardReset;
+        }
+    }
+
+    return PESinkHardReset;
+}
+
+static enum policy_engine_state pe_sink_ready(void)
+{
+    /* Wait for an event */
+    eventmask_t evt = chEvtWaitAny(PDB_EVT_PE_MSG_RX | PDB_EVT_PE_RESET);
+
+    /* If we got reset signaling, transition to default */
+    if (evt & PDB_EVT_PE_RESET) {
+        return PESinkTransitionDefault;
+    }
+
+    /* If we received a message */
+    if (evt & PDB_EVT_PE_MSG_RX) {
+        if (chMBFetch(&pdb_pe_mailbox, (msg_t *) &policy_engine_message, TIME_IMMEDIATE) == MSG_OK) {
+            /* Ignore vendor-defined messages */
+            /* TODO: we're supposed to send NAKs in response to all
+             * unsupported structured VDMs except Attention. */
+            if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_VENDOR_DEFINED
+                    && PD_NUMOBJ_GET(policy_engine_message) > 0) {
+                chPoolFree(&pdb_msg_pool, policy_engine_message);
+                policy_engine_message = NULL;
+                return PESinkReady;
+            /* Ignore Ping messages */
+            } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_PING
+                    && PD_NUMOBJ_GET(policy_engine_message) == 0) {
+                chPoolFree(&pdb_msg_pool, policy_engine_message);
+                policy_engine_message = NULL;
+                return PESinkReady;
+            /* Reject DR_Swap messages */
+            } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_DR_SWAP
+                    && PD_NUMOBJ_GET(policy_engine_message) == 0) {
+                chPoolFree(&pdb_msg_pool, policy_engine_message);
+                policy_engine_message = NULL;
+                return PESinkSendReject;
+            /* Reject Get_Source_Cap messages */
+            } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_GET_SOURCE_CAP
+                    && PD_NUMOBJ_GET(policy_engine_message) == 0) {
+                chPoolFree(&pdb_msg_pool, policy_engine_message);
+                policy_engine_message = NULL;
+                return PESinkSendReject;
+            /* Reject PR_Swap messages */
+            } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_PR_SWAP
+                    && PD_NUMOBJ_GET(policy_engine_message) == 0) {
+                chPoolFree(&pdb_msg_pool, policy_engine_message);
+                policy_engine_message = NULL;
+                return PESinkSendReject;
+            /* Reject VCONN_Swap messages */
+            } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_VCONN_SWAP
+                    && PD_NUMOBJ_GET(policy_engine_message) == 0) {
+                chPoolFree(&pdb_msg_pool, policy_engine_message);
+                policy_engine_message = NULL;
+                return PESinkSendReject;
+            /* Reject Request messages */
+            } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_REQUEST
+                    && PD_NUMOBJ_GET(policy_engine_message) > 0) {
+                chPoolFree(&pdb_msg_pool, policy_engine_message);
+                policy_engine_message = NULL;
+                return PESinkSendReject;
+            /* Reject Sink_Capabilities messages */
+            } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SINK_CAPABILITIES
+                    && PD_NUMOBJ_GET(policy_engine_message) > 0) {
+                chPoolFree(&pdb_msg_pool, policy_engine_message);
+                policy_engine_message = NULL;
+                return PESinkSendReject;
+            /* Evaluate new Source_Capabilities */
+            } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SOURCE_CAPABILITIES
+                    && PD_NUMOBJ_GET(policy_engine_message) > 0) {
+                return PESinkEvalCap;
+            /* Give sink capabilities when asked */
+            } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_GET_SINK_CAP
+                    && PD_NUMOBJ_GET(policy_engine_message) == 0) {
+                chPoolFree(&pdb_msg_pool, policy_engine_message);
+                policy_engine_message = NULL;
+                return PESinkGiveSinkCap;
+            /* If the message was a Soft_Reset, do the soft reset procedure */
+            } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SOFT_RESET
+                    && PD_NUMOBJ_GET(policy_engine_message) == 0) {
+                chPoolFree(&pdb_msg_pool, policy_engine_message);
+                policy_engine_message = NULL;
+                return PESinkSoftReset;
+            /* If we got an unknown message, send a soft reset */
+            } else {
+                chPoolFree(&pdb_msg_pool, policy_engine_message);
+                policy_engine_message = NULL;
+                return PESinkSendSoftReset;
+            }
+        }
+    }
+
+    return PESinkReady;
+}
+
+static enum policy_engine_state pe_sink_get_source_cap(void)
+{
+    /* Stubbed until we actually have a need for this */
+    return PESinkReady;
+}
+
+static enum policy_engine_state pe_sink_give_sink_cap(void)
+{
+    /* Get a message object */
+    union pd_msg *snk_cap = chPoolAlloc(&pdb_msg_pool);
+    /* Get our capabilities from the DPM */
+    pdb_dpm_get_sink_capability(snk_cap);
+
+    /* Transmit our capabilities */
+    chMBPost(&pdb_prltx_mailbox, (msg_t) snk_cap, TIME_IMMEDIATE);
+    chEvtSignal(pdb_prltx_thread, PDB_EVT_PRLTX_MSG_TX);
+    eventmask_t evt = chEvtWaitAny(PDB_EVT_PE_TX_DONE | PDB_EVT_PE_TX_ERR);
+
+    /* Free the Sink_Capabilities message */
+    chPoolFree(&pdb_msg_pool, snk_cap);
+    snk_cap = NULL;
+
+    /* If the message transmission failed, send a hard reset */
+    if ((evt & PDB_EVT_PE_TX_DONE) == 0) {
+        return PESinkHardReset;
+    }
+
+    return PESinkReady;
+}
+
+static enum policy_engine_state pe_sink_hard_reset(void)
+{
+    /* Generate a hard reset signal */
+    chEvtSignal(pdb_hardrst_thread, PDB_EVT_HARDRST_RESET);
+    chEvtWaitAny(PDB_EVT_PE_HARD_SENT);
+
+    /* TODO: maintain HardResetCounter */
+
+    return PESinkTransitionDefault;
+}
+
+static enum policy_engine_state pe_sink_transition_default(void)
+{
+    /* Tell the DPM to turn off the output */
+    pdb_dpm_output_off();
+
+    /* There is no local hardware to reset. */
+    /* Since we never change our data role from UFP, there is no reason to set
+     * it here. */
+
+    /* Tell the protocol layer we're done with the reset */
+    chEvtSignal(pdb_hardrst_thread, PDB_EVT_HARDRST_DONE);
+
+    return PESinkStartup;
+}
+
+static enum policy_engine_state pe_sink_soft_reset(void)
+{
+    /* No need to explicitly reset the protocol layer here.  It resets itself
+     * when a Soft_Reset message is received. */
+
+    /* Get a message object */
+    union pd_msg *accept = chPoolAlloc(&pdb_msg_pool);
+    /* Make an Accept message */
+    accept->hdr = PD_MSGTYPE_ACCEPT | PD_DATAROLE_UFP | PD_SPECREV_2_0
+        | PD_POWERROLE_SINK | PD_NUMOBJ(0);
+    /* Transmit the Accept */
+    chMBPost(&pdb_prltx_mailbox, (msg_t) accept, TIME_IMMEDIATE);
+    chEvtSignal(pdb_prltx_thread, PDB_EVT_PRLTX_MSG_TX);
+    eventmask_t evt = chEvtWaitAny(PDB_EVT_PE_TX_DONE | PDB_EVT_PE_TX_ERR);
+    /* Free the sent message */
+    chPoolFree(&pdb_msg_pool, accept);
+    accept = NULL;
+    /* If the message transmission failed, send a hard reset */
+    if ((evt & PDB_EVT_PE_TX_DONE) == 0) {
+        return PESinkHardReset;
+    }
+
+    return PESinkWaitCap;
+}
+
+static enum policy_engine_state pe_sink_send_soft_reset(void)
+{
+    /* No need to explicitly reset the protocol layer here.  It resets itself
+     * just before a Soft_Reset message is transmitted. */
+
+    /* Get a message object */
+    union pd_msg *softrst = chPoolAlloc(&pdb_msg_pool);
+    /* Make a Soft_Reset message */
+    softrst->hdr = PD_MSGTYPE_SOFT_RESET | PD_DATAROLE_UFP | PD_SPECREV_2_0
+        | PD_POWERROLE_SINK | PD_NUMOBJ(0);
+    /* Transmit the soft reset */
+    chMBPost(&pdb_prltx_mailbox, (msg_t) softrst, TIME_IMMEDIATE);
+    chEvtSignal(pdb_prltx_thread, PDB_EVT_PRLTX_MSG_TX);
+    eventmask_t evt = chEvtWaitAny(PDB_EVT_PE_TX_DONE | PDB_EVT_PE_TX_ERR);
+    /* Free the sent message */
+    chPoolFree(&pdb_msg_pool, softrst);
+    softrst = NULL;
+    /* If the message transmission failed, send a hard reset */
+    if ((evt & PDB_EVT_PE_TX_DONE) == 0) {
+        return PESinkHardReset;
+    }
+
+    /* Wait for a response */
+    evt = chEvtWaitAnyTimeout(PDB_EVT_PE_MSG_RX, PD_T_SENDER_RESPONSE);
+    /* If we didn't get a response before the timeout, send a hard reset */
+    if (evt == 0) {
+        return PESinkHardReset;
+    }
+
+    /* Get the response message */
+    if (chMBFetch(&pdb_pe_mailbox, (msg_t *) &policy_engine_message, TIME_IMMEDIATE) == MSG_OK) {
+        /* If the source accepted our soft reset, wait for capabilities. */
+        if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_ACCEPT
+                && PD_NUMOBJ_GET(policy_engine_message) == 0) {
+            chPoolFree(&pdb_msg_pool, policy_engine_message);
+            policy_engine_message = NULL;
+            return PESinkWaitCap;
+        /* If the message was a Soft_Reset, do the soft reset procedure */
+        } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SOFT_RESET
+                && PD_NUMOBJ_GET(policy_engine_message) == 0) {
+            chPoolFree(&pdb_msg_pool, policy_engine_message);
+            policy_engine_message = NULL;
+            return PESinkSoftReset;
+        /* Otherwise, send a hard reset */
+        } else {
+            chPoolFree(&pdb_msg_pool, policy_engine_message);
+            policy_engine_message = NULL;
+            return PESinkHardReset;
+        }
+    }
+    return PESinkHardReset;
+}
+
+static enum policy_engine_state pe_sink_send_reject(void)
+{
+    /* Get a message object */
+    union pd_msg *reject = chPoolAlloc(&pdb_msg_pool);
+    /* Make a Reject message */
+    reject->hdr = PD_MSGTYPE_REJECT | PD_DATAROLE_UFP | PD_SPECREV_2_0
+        | PD_POWERROLE_SINK | PD_NUMOBJ(0);
+
+    /* Transmit the message */
+    chMBPost(&pdb_prltx_mailbox, (msg_t) reject, TIME_IMMEDIATE);
+    chEvtSignal(pdb_prltx_thread, PDB_EVT_PRLTX_MSG_TX);
+    eventmask_t evt = chEvtWaitAny(PDB_EVT_PE_TX_DONE | PDB_EVT_PE_TX_ERR);
+
+    /* Free the Reject message */
+    chPoolFree(&pdb_msg_pool, reject);
+    reject = NULL;
+
+    /* If the message transmission failed, send a soft reset */
+    if ((evt & PDB_EVT_PE_TX_DONE) == 0) {
+        return PESinkSendSoftReset;
+    }
+
+    return PESinkReady;
+}
+
+/*
+ * Policy Engine state machine thread
+ */
+static THD_WORKING_AREA(waPolicyEngine, 128);
+static THD_FUNCTION(PolicyEngine, arg) {
+    (void) arg;
+    enum policy_engine_state state = PESinkStartup;
+
+    /* Initialize the mailbox */
+    chMBObjectInit(&pdb_pe_mailbox, pdb_pe_mailbox_queue, PDB_MSG_POOL_SIZE);
+
+    while (true) {
+        switch (state) {
+            case PESinkStartup:
+                state = pe_sink_startup();
+                break;
+            case PESinkDiscovery:
+                state = pe_sink_discovery();
+                break;
+            case PESinkWaitCap:
+                state = pe_sink_wait_cap();
+                break;
+            case PESinkEvalCap:
+                state = pe_sink_eval_cap();
+                break;
+            case PESinkSelectCap:
+                state = pe_sink_select_cap();
+                break;
+            case PESinkTransitionSink:
+                state = pe_sink_transition_sink();
+                break;
+            case PESinkReady:
+                state = pe_sink_ready();
+                break;
+            case PESinkGetSourceCap:
+                state = pe_sink_get_source_cap();
+                break;
+            case PESinkGiveSinkCap:
+                state = pe_sink_give_sink_cap();
+                break;
+            case PESinkHardReset:
+                state = pe_sink_hard_reset();
+                break;
+            case PESinkTransitionDefault:
+                state = pe_sink_transition_default();
+                break;
+            case PESinkSoftReset:
+                state = pe_sink_soft_reset();
+                break;
+            case PESinkSendSoftReset:
+                state = pe_sink_send_soft_reset();
+                break;
+            case PESinkSendReject:
+                state = pe_sink_send_reject();
+                break;
+            default:
+                /* This is an error.  It really shouldn't happen.  We might
+                 * want to handle it anyway, though. */
+                state = PESinkStartup;
+                break;
+        }
+    }
+}
+
+void pdb_pe_run(void)
+{
+    pdb_pe_thread = chThdCreateStatic(waPolicyEngine, sizeof(waPolicyEngine),
+            PDB_PRIO_PE, PolicyEngine, NULL);
+}

src/policy_engine.h

@@ -0,0 +1,44 @@
+/*
+ * 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_POLICY_ENGINE_H
+#define PDB_POLICY_ENGINE_H
+
+#include <ch.h>
+
+
+/* Events for the Policy Engine thread */
+#define PDB_EVT_PE_RESET EVENT_MASK(0)
+#define PDB_EVT_PE_MSG_RX EVENT_MASK(1)
+#define PDB_EVT_PE_TX_DONE EVENT_MASK(2)
+#define PDB_EVT_PE_TX_ERR EVENT_MASK(3)
+#define PDB_EVT_PE_HARD_SENT EVENT_MASK(4)
+
+/* The Policy Engine thread object */
+extern thread_t *pdb_pe_thread;
+
+/* Policy Engine thread mailbox */
+extern mailbox_t pdb_pe_mailbox;
+
+/*
+ * Start the Policy Engine thread
+ */
+void pdb_pe_run(void);
+
+
+#endif /* PDB_POLICY_ENGINE_H */

src/priorities.h

@@ -0,0 +1,33 @@
+/*
+ * 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_PRIORITIES_H
+#define PDB_PRIORITIES_H
+
+
+#include <ch.h>
+
+/* PD Buddy thread priorities */
+#define PDB_PRIO_PE (NORMALPRIO - 1)
+#define PDB_PRIO_PRL (PDB_PRIO_PE - 1)
+#define PDB_PRIO_PRL_INT_N (PDB_PRIO_PRL - 1)
+
+#define PDB_PRIO_LED HIGHPRIO
+
+
+#endif /* PDB_PRIORITIES_H */

src/protocol_rx.c

@@ -0,0 +1,190 @@
+/*
+ * 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 "protocol_rx.h"
+
+#include <stdlib.h>
+
+#include "priorities.h"
+#include "policy_engine.h"
+#include "protocol_tx.h"
+#include "fusb302b.h"
+#include "messages.h"
+#include "pd.h"
+
+
+thread_t *pdb_prlrx_thread;
+
+/*
+ * Protocol RX machine states
+ *
+ * There is no Send_GoodCRC state because the PHY sends the GoodCRC for us.
+ * All transitions that would go to that state instead go to Check_MessageID.
+ */
+enum protocol_rx_state {
+    PRLRxWaitPHY,
+    PRLRxReset,
+    PRLRxCheckMessageID,
+    PRLRxStoreMessageID
+};
+
+/* The received message we're currently working with */
+static union pd_msg *protocol_rx_message = NULL;
+/* The ID of the last received message */
+int8_t pdb_prlrx_messageid = -1;
+
+/*
+ * PRL_Rx_Wait_for_PHY_Message state
+ */
+static enum protocol_rx_state protocol_rx_wait_phy(void)
+{
+    /* Wait for an event */
+    eventmask_t evt = chEvtWaitAny(ALL_EVENTS);
+
+    /* If we got a reset event, reset */
+    if (evt & PDB_EVT_PRLRX_RESET) {
+        return PRLRxWaitPHY;
+    }
+    /* If we got an I_GCRCSENT event, read the message and decide what to do */
+    if (evt & PDB_EVT_PRLRX_I_GCRCSENT) {
+        /* Get a buffer to read the message into.  Guaranteed to not fail
+         * because we have a big enough pool and are careful. */
+        protocol_rx_message = chPoolAlloc(&pdb_msg_pool);
+        /* Read the message */
+        fusb_read_message(protocol_rx_message);
+        /* If it's a Soft_Reset, go to the soft reset state */
+        if (PD_MSGTYPE_GET(protocol_rx_message) == PD_MSGTYPE_SOFT_RESET
+                && PD_NUMOBJ_GET(protocol_rx_message) == 0) {
+            return PRLRxReset;
+        /* Otherwise, check the message ID */
+        } else {
+            return PRLRxCheckMessageID;
+        }
+    }
+
+    /* We shouldn't ever get here.  This just silence the compiler warning. */
+    return PRLRxWaitPHY;
+}
+
+/*
+ * PRL_Rx_Layer_Reset_for_Receive state
+ */
+static enum protocol_rx_state protocol_rx_reset(void)
+{
+    /* Reset MessageIDCounter */
+    pdb_prltx_messageidcounter = 0;
+
+    /* Clear stored MessageID */
+    pdb_prlrx_messageid = -1;
+
+    /* TX transitions to its reset state */
+    chEvtSignal(pdb_prltx_thread, PDB_EVT_PRLTX_RESET);
+    chThdYield();
+
+    /* If we got a RESET signal, reset the machine */
+    if (chEvtGetAndClearEvents(PDB_EVT_PRLRX_RESET) != 0) {
+        chPoolFree(&pdb_msg_pool, protocol_rx_message);
+        protocol_rx_message = NULL;
+        return PRLRxWaitPHY;
+    }
+
+    /* Go to the Check_MessageID state */
+    return PRLRxCheckMessageID;
+}
+
+/*
+ * PRL_Rx_Check_MessageID state
+ */
+static enum protocol_rx_state protocol_rx_check_messageid(void)
+{
+    /* If we got a RESET signal, reset the machine */
+    if (chEvtGetAndClearEvents(PDB_EVT_PRLRX_RESET) != 0) {
+        chPoolFree(&pdb_msg_pool, protocol_rx_message);
+        protocol_rx_message = NULL;
+        return PRLRxWaitPHY;
+    }
+
+    /* If the message has the stored ID, we've seen this message before.  Free
+     * it and don't pass it to the policy engine. */
+    if (PD_MESSAGEID_GET(protocol_rx_message) == pdb_prlrx_messageid) {
+        chPoolFree(&pdb_msg_pool, protocol_rx_message);
+        protocol_rx_message = NULL;
+        return PRLRxWaitPHY;
+    /* Otherwise, there's either no stored ID or this message has an ID we
+     * haven't just seen.  Transition to the Store_MessageID state. */
+    } else {
+        return PRLRxStoreMessageID;
+    }
+}
+
+/*
+ * PRL_Rx_Store_MessageID state
+ */
+static enum protocol_rx_state protocol_rx_store_messageid(void)
+{
+    /* Tell ProtocolTX to discard the message being transmitted */
+    chEvtSignal(pdb_prltx_thread, PDB_EVT_PRLTX_DISCARD);
+    chThdYield();
+
+    /* Update the stored MessageID */
+    pdb_prlrx_messageid = PD_MESSAGEID_GET(protocol_rx_message);
+
+    /* Pass the message to the policy engine. */
+    chMBPost(&pdb_pe_mailbox, (msg_t) protocol_rx_message, TIME_IMMEDIATE);
+    chEvtSignal(pdb_pe_thread, PDB_EVT_PE_MSG_RX);
+
+    /* Don't check if we got a RESET because we'd do nothing different. */
+
+    return PRLRxWaitPHY;
+}
+
+/*
+ * Protocol layer RX state machine thread
+ */
+static THD_WORKING_AREA(waProtocolRX, 128);
+static THD_FUNCTION(ProtocolRX, arg) {
+    (void) arg;
+    enum protocol_rx_state state = PRLRxWaitPHY;
+
+    while (true) {
+        switch (state) {
+            case PRLRxWaitPHY:
+                state = protocol_rx_wait_phy();
+                break;
+            case PRLRxReset:
+                state = protocol_rx_reset();
+                break;
+            case PRLRxCheckMessageID:
+                state = protocol_rx_check_messageid();
+                break;
+            case PRLRxStoreMessageID:
+                state = protocol_rx_store_messageid();
+                break;
+            default:
+                /* This is an error.  It really shouldn't happen.  We might
+                 * want to handle it anyway, though. */
+                break;
+        }
+    }
+}
+
+void pdb_prlrx_run(void)
+{
+    pdb_prlrx_thread = chThdCreateStatic(waProtocolRX, sizeof(waProtocolRX),
+            PDB_PRIO_PRL, ProtocolRX, NULL);
+}

src/protocol_rx.h

@@ -0,0 +1,43 @@
+/*
+ * 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_PROTOCOL_RX_H
+#define PDB_PROTOCOL_RX_H
+
+#include <stdint.h>
+
+#include <ch.h>
+
+
+/* Events for the Protocol RX thread */
+#define PDB_EVT_PRLRX_RESET EVENT_MASK(0)
+#define PDB_EVT_PRLRX_I_GCRCSENT EVENT_MASK(1)
+
+/* The Protocol RX thread object */
+extern thread_t *pdb_prlrx_thread;
+
+/* The last received MessageID */
+extern int8_t pdb_prlrx_messageid;
+
+/*
+ * Start the Protocol RX thread
+ */
+void pdb_prlrx_run(void);
+
+
+#endif /* PDB_PROTOCOL_RX_H */

src/protocol_tx.c

@@ -0,0 +1,289 @@
+/*
+ * 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 "protocol_tx.h"
+
+#include "priorities.h"
+#include "policy_engine.h"
+#include "protocol_rx.h"
+#include "fusb302b.h"
+#include "messages.h"
+#include "pd.h"
+
+
+thread_t *pdb_prltx_thread;
+
+/* Protocol layer TX thread mailbox */
+static msg_t pdb_prltx_mailbox_queue[PDB_MSG_POOL_SIZE];
+mailbox_t pdb_prltx_mailbox;
+
+/*
+ * Protocol TX machine states
+ *
+ * Because the PHY can automatically send retries, the Check_RetryCounter state
+ * has been removed, transitions relating to it are modified appropriately, and
+ * we don't even keep a RetryCounter.
+ */
+enum protocol_tx_state {
+    PRLTxPHYReset,
+    PRLTxWaitMessage,
+    PRLTxReset,
+    PRLTxConstructMessage,
+    PRLTxWaitResponse,
+    PRLTxMatchMessageID,
+    PRLTxTransmissionError,
+    PRLTxMessageSent,
+    PRLTxDiscardMessage
+};
+
+/* The message we're currently working on transmitting */
+static union pd_msg *protocol_tx_message = NULL;
+/* The ID to be used in transmission */
+int8_t pdb_prltx_messageidcounter = 0;
+
+
+/*
+ * PRL_Tx_PHY_Layer_Reset state
+ */
+static enum protocol_tx_state protocol_tx_phy_reset(void)
+{
+    /* Reset the PHY */
+    fusb_reset();
+
+    /* If a message was pending when we got here, tell the policy engine that
+     * we failed to send it */
+    if (protocol_tx_message != NULL) {
+        /* Tell the policy engine that we failed */
+        chEvtSignal(pdb_pe_thread, PDB_EVT_PE_TX_ERR);
+        /* Finish failing to send the message */
+        protocol_tx_message = NULL;
+    }
+
+    /* Wait for a message request */
+    return PRLTxWaitMessage;
+}
+
+/*
+ * PRL_Tx_Wait_for_Message_Request state
+ */
+static enum protocol_tx_state protocol_tx_wait_message(void)
+{
+    /* Wait for an event */
+    eventmask_t evt = chEvtWaitAny(PDB_EVT_PRLTX_RESET | PDB_EVT_PRLTX_DISCARD
+            | PDB_EVT_PRLTX_MSG_TX);
+
+    if (evt & PDB_EVT_PRLTX_RESET) {
+        return PRLTxPHYReset;
+    }
+    if (evt & PDB_EVT_PRLTX_DISCARD) {
+        return PRLTxDiscardMessage;
+    }
+
+    /* If the policy engine is trying to send a message */
+    if (evt & PDB_EVT_PRLTX_MSG_TX) {
+        /* Get the message */
+        chMBFetch(&pdb_prltx_mailbox, (msg_t *) &protocol_tx_message, TIME_IMMEDIATE);
+        /* If it's a Soft_Reset, reset the TX layer first */
+        if (PD_MSGTYPE_GET(protocol_tx_message) == PD_MSGTYPE_SOFT_RESET
+                && PD_NUMOBJ_GET(protocol_tx_message) == 0) {
+            return PRLTxReset;
+        /* Otherwise, just send the message */
+        } else {
+            return PRLTxConstructMessage;
+        }
+    }
+
+    /* Silence the compiler warning */
+    return PRLTxDiscardMessage;
+}
+
+static enum protocol_tx_state protocol_tx_reset(void)
+{
+    /* Clear MessageIDCounter */
+    pdb_prltx_messageidcounter = 0;
+
+    /* Tell the Protocol RX thread to reset */
+    chEvtSignal(pdb_prlrx_thread, PDB_EVT_PRLRX_RESET);
+    chThdYield();
+
+    return PRLTxConstructMessage;
+}
+
+/*
+ * PRL_Tx_Construct_Message state
+ */
+static enum protocol_tx_state protocol_tx_construct_message(void)
+{
+    /* Make sure nobody wants us to reset */
+    eventmask_t evt = chEvtGetAndClearEvents(PDB_EVT_PRLTX_RESET | PDB_EVT_PRLTX_DISCARD);
+
+    if (evt & PDB_EVT_PRLTX_RESET) {
+        return PRLTxPHYReset;
+    }
+    if (evt & PDB_EVT_PRLTX_DISCARD) {
+        return PRLTxDiscardMessage;
+    }
+
+    /* Set the correct MessageID in the message */
+    protocol_tx_message->hdr &= ~PD_HDR_MESSAGEID;
+    protocol_tx_message->hdr |= pdb_prltx_messageidcounter << PD_HDR_MESSAGEID_SHIFT;
+
+    /* Send the message to the PHY */
+    fusb_send_message(protocol_tx_message);
+
+    return PRLTxWaitResponse;
+}
+
+/*
+ * PRL_Tx_Wait_for_PHY_Response state
+ */
+static enum protocol_tx_state protocol_tx_wait_response(void)
+{
+    /* Wait for an event.  There is no need to run CRCReceiveTimer, since the
+     * FUSB302B handles that as part of its retry mechanism. */
+    eventmask_t evt = chEvtWaitAny(PDB_EVT_PRLTX_RESET | PDB_EVT_PRLTX_DISCARD
+            | PDB_EVT_PRLTX_I_TXSENT | PDB_EVT_PRLTX_I_RETRYFAIL);
+
+    if (evt & PDB_EVT_PRLTX_RESET) {
+        return PRLTxPHYReset;
+    }
+    if (evt & PDB_EVT_PRLTX_DISCARD) {
+        return PRLTxDiscardMessage;
+    }
+
+    /* If the message was sent successfully */
+    if (evt & PDB_EVT_PRLTX_I_TXSENT) {
+        return PRLTxMatchMessageID;
+    }
+    /* If the message failed to be sent */
+    if (evt & PDB_EVT_PRLTX_I_RETRYFAIL) {
+        return PRLTxTransmissionError;
+    }
+
+    /* Silence the compiler warning */
+    return PRLTxDiscardMessage;
+}
+
+/*
+ * PRL_Tx_Match_MessageID state
+ */
+static enum protocol_tx_state protocol_tx_match_messageid(void)
+{
+    union pd_msg goodcrc;
+
+    /* Read the GoodCRC */
+    fusb_read_message(&goodcrc);
+
+    /* Check that the message is correct */
+    if (PD_MSGTYPE_GET(&goodcrc) == PD_MSGTYPE_GOODCRC
+            && PD_NUMOBJ_GET(&goodcrc) == 0
+            && PD_MESSAGEID_GET(&goodcrc) == pdb_prltx_messageidcounter) {
+        return PRLTxMessageSent;
+    } else {
+        return PRLTxTransmissionError;
+    }
+}
+
+static enum protocol_tx_state protocol_tx_transmission_error(void)
+{
+    /* Increment MessageIDCounter */
+    pdb_prltx_messageidcounter = (pdb_prltx_messageidcounter + 1) % 8;
+
+    /* Tell the policy engine that we failed */
+    chEvtSignal(pdb_pe_thread, PDB_EVT_PE_TX_ERR);
+
+    protocol_tx_message = NULL;
+    return PRLTxWaitMessage;
+}
+
+static enum protocol_tx_state protocol_tx_message_sent(void)
+{
+    /* Increment MessageIDCounter */
+    pdb_prltx_messageidcounter = (pdb_prltx_messageidcounter + 1) % 8;
+
+    /* Tell the policy engine that we succeeded */
+    chEvtSignal(pdb_pe_thread, PDB_EVT_PE_TX_DONE);
+
+    protocol_tx_message = NULL;
+    return PRLTxWaitMessage;
+}
+
+static enum protocol_tx_state protocol_tx_discard_message(void)
+{
+    /* If we were working on sending a message, increment MessageIDCounter */
+    if (protocol_tx_message != NULL) {
+        pdb_prltx_messageidcounter = (pdb_prltx_messageidcounter + 1) % 8;
+    }
+
+    return PRLTxPHYReset;
+}
+
+/*
+ * Protocol layer TX state machine thread
+ */
+static THD_WORKING_AREA(waProtocolTX, 128);
+static THD_FUNCTION(ProtocolTX, arg) {
+    (void) arg;
+
+    enum protocol_tx_state state = PRLTxPHYReset;
+
+    /* Initialize the mailbox */
+    chMBObjectInit(&pdb_prltx_mailbox, pdb_prltx_mailbox_queue, PDB_MSG_POOL_SIZE);
+
+    while (true) {
+        switch (state) {
+            case PRLTxPHYReset:
+                state = protocol_tx_phy_reset();
+                break;
+            case PRLTxWaitMessage:
+                state = protocol_tx_wait_message();
+                break;
+            case PRLTxReset:
+                state = protocol_tx_reset();
+                break;
+            case PRLTxConstructMessage:
+                state = protocol_tx_construct_message();
+                break;
+            case PRLTxWaitResponse:
+                state = protocol_tx_wait_response();
+                break;
+            case PRLTxMatchMessageID:
+                state = protocol_tx_match_messageid();
+                break;
+            case PRLTxTransmissionError:
+                state = protocol_tx_transmission_error();
+                break;
+            case PRLTxMessageSent:
+                state = protocol_tx_message_sent();
+                break;
+            case PRLTxDiscardMessage:
+                state = protocol_tx_discard_message();
+                break;
+            default:
+                /* This is an error.  It really shouldn't happen.  We might
+                 * want to handle it anyway, though. */
+                break;
+        }
+    }
+}
+
+void pdb_prltx_run(void)
+{
+    pdb_prltx_thread = chThdCreateStatic(waProtocolTX, sizeof(waProtocolTX),
+            PDB_PRIO_PRL, ProtocolTX, NULL);
+}

src/protocol_tx.h

@@ -0,0 +1,49 @@
+/*
+ * 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_PROTOCOL_TX_H
+#define PDB_PROTOCOL_TX_H
+
+#include <stdint.h>
+
+#include <ch.h>
+
+
+/* Events for the Protocol TX thread */
+#define PDB_EVT_PRLTX_RESET EVENT_MASK(0)
+#define PDB_EVT_PRLTX_I_TXSENT EVENT_MASK(1)
+#define PDB_EVT_PRLTX_I_RETRYFAIL EVENT_MASK(2)
+#define PDB_EVT_PRLTX_DISCARD EVENT_MASK(3)
+#define PDB_EVT_PRLTX_MSG_TX EVENT_MASK(4)
+
+/* The Protocol TX thread object */
+extern thread_t *pdb_prltx_thread;
+
+/* Protocol layer TX thread mailbox */
+extern mailbox_t pdb_prltx_mailbox;
+
+/* The ID to be used in transmission */
+extern int8_t pdb_prltx_messageidcounter;
+
+/*
+ * Start the Protocol TX thread
+ */
+void pdb_prltx_run(void);
+
+
+#endif /* PDB_PROTOCOL_TX_H */