Make the library work, to an extent

The code compiles again, and it seems to work as it did before.  There's
still a lot to do (we still have a mess of globals), but the PE
correctly calls the new DPM functions via the list of callbacks in the
configuration object.

Makefile

 #
 
 # List all user C define here, like -D_DEBUG=1
-UDEFS = -DPDB_CONFIG_BASE=0x0800F800
+UDEFS = -DPDBS_CONFIG_BASE=0x0800F800
 
 # Define ASM defines here
 UADEFS =

lib/include/fusb302b.h

 
 #include <stdint.h>
 
+#include <pdb_fusb.h>
+
 #include "messages.h"
 
 
 /*
  * Initialization routine for the FUSB302B
  */
-void fusb_setup(void);
+void fusb_setup(struct pdb_fusb_config *);
 
 /*
  * Reset the FUSB302B

lib/include/pdb.h

  */
 struct pdb_config {
     /* Configuration information for the FUSB302B* chip */
-    struct pdb_fusb_config fusb_config;
+    struct pdb_fusb_config fusb;
     /* DPM callbacks */
     struct pdb_dpm_callbacks dpm;
     /* Pointer to port-specific DPM data */

lib/include/pdb_dpm.h

 typedef bool (*pdb_dpm_eval_cap_func)(struct pdb_config *,
         const union pd_msg *, union pd_msg *);
 typedef void (*pdb_dpm_get_sink_cap_func)(struct pdb_config *, union pd_msg *);
-typedef void (*pdb_dpm_tcc_func)(struct pdb_config *, enum fusb_typec_current);
+typedef bool (*pdb_dpm_giveback_func)(struct pdb_config *);
+typedef bool (*pdb_dpm_tcc_func)(struct pdb_config *, enum fusb_typec_current);
 
 /*
  * PD Buddy firmware library device policy manager callback structure
 struct pdb_dpm_callbacks {
     pdb_dpm_eval_cap_func evaluate_capability;
     pdb_dpm_get_sink_cap_func get_sink_capability;
-    pdb_dpm_func giveback_enabled;
+    pdb_dpm_giveback_func giveback_enabled;
     pdb_dpm_tcc_func evaluate_typec_current; /* Optional */
     pdb_dpm_func pd_start; /* Optional */
     /* dpm_sink_standby is called in PE_SNK_Select_Capability to ensure power

lib/include/policy_engine.h

 
 #include <ch.h>
 
+#include <pdb.h>
+
 
 /* Events for the Policy Engine thread */
 #define PDB_EVT_PE_RESET EVENT_MASK(0)
 /*
  * Start the Policy Engine thread
  */
-void pdb_pe_run(void);
+void pdb_pe_run(struct pdb_config *cfg);
 
 
 #endif /* PDB_POLICY_ENGINE_H */

lib/src/fusb302b.c

     i2cReleaseBus(&I2CD2);
 }
 
-void fusb_setup(void)
+void fusb_setup(struct pdb_fusb_config *cfg)
 {
-    i2cAcquireBus(&I2CD2);
+    i2cAcquireBus(cfg->i2cp);
 
     /* Fully reset the FUSB302B */
     fusb_write_byte(FUSB_RESET, FUSB_RESET_SW_RES);
     /* Reset the PD logic */
     fusb_write_byte(FUSB_RESET, FUSB_RESET_PD_RESET);
 
-    i2cReleaseBus(&I2CD2);
+    i2cReleaseBus(cfg->i2cp);
 }
 
 void fusb_get_status(union fusb_status *status)

lib/src/int_n.h

  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef PDB_INT_N_H
-#define PDB_INT_N_H
+#ifndef PDB_INT_N_OLD_H
+#define PDB_INT_N_OLD_H
 
 
 /*
 void pdb_int_n_run(void);
 
 
-#endif /* PDB_INT_N_H */
+#endif /* PDB_INT_N_OLD_H */

lib/src/pdb.c

 void pdb_init(struct pdb_config *cfg)
 {
     /* Initialize the FUSB302B */
-    fusb_setup(cfg);
+    fusb_setup(&cfg->fusb);
 
     /* Create the policy engine thread. */
     pdb_pe_run(cfg);
 
     /* Create the protocol layer threads. */
-    pdb_prlrx_run(cfg);
-    pdb_prltx_run(cfg);
-    pdb_hardrst_run(cfg);
+    pdb_prlrx_run(/*cfg*/);
+    pdb_prltx_run(/*cfg*/);
+    pdb_hardrst_run(/*cfg*/);
 
     /* Create the INT_N thread. */
-    pdb_int_n_run(cfg);
+    pdb_int_n_run(/*cfg*/);
 }

lib/src/policy_engine.c

 
 #include "messages.h"
 #include "priorities.h"
-#include "device_policy_manager.h"
 #include "protocol_tx.h"
 #include "hard_reset.h"
 #include "fusb302b.h"
 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)
+static enum policy_engine_state pe_sink_startup(struct pdb_config *cfg)
 {
     /* We don't have an explicit contract currently */
     explicit_contract = false;
     /* Tell the DPM that we've started negotiations */
-    pdb_dpm_pd_start();
+    cfg->dpm.pd_start(cfg);
 
     /* 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
     return PESinkDiscovery;
 }
 
-static enum policy_engine_state pe_sink_discovery(void)
+static enum policy_engine_state pe_sink_discovery(struct pdb_config *cfg)
 {
     /* 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)
+static enum policy_engine_state pe_sink_wait_cap(struct pdb_config *cfg)
 {
     /* Fetch a message from the protocol layer */
     eventmask_t evt = chEvtWaitAnyTimeout(PDB_EVT_PE_MSG_RX
     return PESinkHardReset;
 }
 
-static enum policy_engine_state pe_sink_eval_cap(void)
+static enum policy_engine_state pe_sink_eval_cap(struct pdb_config *cfg)
 {
     /* Get a message object for the request if we don't have one already */
     if (last_dpm_request == NULL) {
         last_dpm_request = chPoolAlloc(&pdb_msg_pool);
     }
     /* Ask the DPM what to request */
-    capability_match = pdb_dpm_evaluate_capability(policy_engine_message,
+    capability_match = cfg->dpm.evaluate_capability(cfg, policy_engine_message,
             last_dpm_request);
     /* It's up to the DPM to free the Source_Capabilities message, which it can
      * do whenever it sees fit.  Just remove our reference to it since we won't
     return PESinkSelectCap;
 }
 
-static enum policy_engine_state pe_sink_select_cap(void)
+static enum policy_engine_state pe_sink_select_cap(struct pdb_config *cfg)
 {
     /* Transmit the request */
     chMBPost(&pdb_prltx_mailbox, (msg_t) last_dpm_request, TIME_IMMEDIATE);
         if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_ACCEPT
                 && PD_NUMOBJ_GET(policy_engine_message) == 0) {
             /* Transition to Sink Standby if necessary */
-            pdb_dpm_sink_standby();
+            cfg->dpm.transition_standby(cfg);
 
             min_power = false;
 
     return PESinkHardReset;
 }
 
-static enum policy_engine_state pe_sink_transition_sink(void)
+static enum policy_engine_state pe_sink_transition_sink(struct pdb_config *cfg)
 {
     /* Wait for the PS_RDY message */
     eventmask_t evt = chEvtWaitAnyTimeout(PDB_EVT_PE_MSG_RX | PDB_EVT_PE_RESET,
 
             /* Set the output appropriately */
             if (!min_power) {
-                pdb_dpm_output_set(capability_match);
+                cfg->dpm.transition_requested(cfg);
             }
 
             chPoolFree(&pdb_msg_pool, policy_engine_message);
             /* 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_set(false);
+            cfg->dpm.transition_default(cfg);
 
             chPoolFree(&pdb_msg_pool, policy_engine_message);
             policy_engine_message = NULL;
     return PESinkHardReset;
 }
 
-static enum policy_engine_state pe_sink_ready(void)
+static enum policy_engine_state pe_sink_ready(struct pdb_config *cfg)
 {
     eventmask_t evt;
 
             /* Handle GotoMin messages */
             } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_GOTOMIN
                     && PD_NUMOBJ_GET(policy_engine_message) == 0) {
-                if (pdb_dpm_giveback_enabled()) {
-                    /* We support GiveBack, so go to minimum power */
-                    pdb_dpm_output_set(false);
+                if (cfg->dpm.giveback_enabled(cfg)) {
+                    /* Transition to the minimum current level */
+                    cfg->dpm.transition_min(cfg);
                     min_power = true;
 
                     chPoolFree(&pdb_msg_pool, policy_engine_message);
     return PESinkReady;
 }
 
-static enum policy_engine_state pe_sink_get_source_cap(void)
+static enum policy_engine_state pe_sink_get_source_cap(struct pdb_config *cfg)
 {
     /* Get a message object */
     union pd_msg *get_source_cap = chPoolAlloc(&pdb_msg_pool);
     return PESinkReady;
 }
 
-static enum policy_engine_state pe_sink_give_sink_cap(void)
+static enum policy_engine_state pe_sink_give_sink_cap(struct pdb_config *cfg)
 {
     /* 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);
+    cfg->dpm.get_sink_capability(cfg, snk_cap);
 
     /* Transmit our capabilities */
     chMBPost(&pdb_prltx_mailbox, (msg_t) snk_cap, TIME_IMMEDIATE);
     return PESinkReady;
 }
 
-static enum policy_engine_state pe_sink_hard_reset(void)
+static enum policy_engine_state pe_sink_hard_reset(struct pdb_config *cfg)
 {
     /* If we've already sent the maximum number of hard resets, assume the
      * source is unresponsive. */
     return PESinkTransitionDefault;
 }
 
-static enum policy_engine_state pe_sink_transition_default(void)
+static enum policy_engine_state pe_sink_transition_default(struct pdb_config *cfg)
 {
     explicit_contract = false;
 
     /* Tell the DPM to transition to default power */
-    pdb_dpm_output_default();
+    cfg->dpm.transition_default(cfg);
 
     /* There is no local hardware to reset. */
     /* Since we never change our data role from UFP, there is no reason to set
     return PESinkStartup;
 }
 
-static enum policy_engine_state pe_sink_soft_reset(void)
+static enum policy_engine_state pe_sink_soft_reset(struct pdb_config *cfg)
 {
     /* No need to explicitly reset the protocol layer here.  It resets itself
      * when a Soft_Reset message is received. */
     return PESinkWaitCap;
 }
 
-static enum policy_engine_state pe_sink_send_soft_reset(void)
+static enum policy_engine_state pe_sink_send_soft_reset(struct pdb_config *cfg)
 {
     /* No need to explicitly reset the protocol layer here.  It resets itself
      * just before a Soft_Reset message is transmitted. */
     return PESinkHardReset;
 }
 
-static enum policy_engine_state pe_sink_send_reject(void)
+static enum policy_engine_state pe_sink_send_reject(struct pdb_config *cfg)
 {
     /* Get a message object */
     union pd_msg *reject = chPoolAlloc(&pdb_msg_pool);
 /*
  * When Power Delivery is unresponsive, fall back to Type-C Current
  */
-static enum policy_engine_state pe_sink_source_unresponsive(void)
+static enum policy_engine_state pe_sink_source_unresponsive(struct pdb_config *cfg)
 {
     static int old_tcc_match = -1;
-    int tcc_match = pdb_dpm_evaluate_typec_current(fusb_get_typec_current());
+    int tcc_match = cfg->dpm.evaluate_typec_current(cfg, fusb_get_typec_current());
 
     /* If the last two readings are the same, set the output */
     if (old_tcc_match == tcc_match) {
-        pdb_dpm_output_set(tcc_match);
+        cfg->dpm.transition_typec(cfg);
     }
 
     /* Remember whether or not the last measurement succeeded */
  * Policy Engine state machine thread
  */
 static THD_WORKING_AREA(waPolicyEngine, 128);
-static THD_FUNCTION(PolicyEngine, arg) {
-    (void) arg;
+static THD_FUNCTION(PolicyEngine, cfg) {
     enum policy_engine_state state = PESinkStartup;
 
     /* Initialize the mailbox */
     while (true) {
         switch (state) {
             case PESinkStartup:
-                state = pe_sink_startup();
+                state = pe_sink_startup(cfg);
                 break;
             case PESinkDiscovery:
-                state = pe_sink_discovery();
+                state = pe_sink_discovery(cfg);
                 break;
             case PESinkWaitCap:
-                state = pe_sink_wait_cap();
+                state = pe_sink_wait_cap(cfg);
                 break;
             case PESinkEvalCap:
-                state = pe_sink_eval_cap();
+                state = pe_sink_eval_cap(cfg);
                 break;
             case PESinkSelectCap:
-                state = pe_sink_select_cap();
+                state = pe_sink_select_cap(cfg);
                 break;
             case PESinkTransitionSink:
-                state = pe_sink_transition_sink();
+                state = pe_sink_transition_sink(cfg);
                 break;
             case PESinkReady:
-                state = pe_sink_ready();
+                state = pe_sink_ready(cfg);
                 break;
             case PESinkGetSourceCap:
-                state = pe_sink_get_source_cap();
+                state = pe_sink_get_source_cap(cfg);
                 break;
             case PESinkGiveSinkCap:
-                state = pe_sink_give_sink_cap();
+                state = pe_sink_give_sink_cap(cfg);
                 break;
             case PESinkHardReset:
-                state = pe_sink_hard_reset();
+                state = pe_sink_hard_reset(cfg);
                 break;
             case PESinkTransitionDefault:
-                state = pe_sink_transition_default();
+                state = pe_sink_transition_default(cfg);
                 break;
             case PESinkSoftReset:
-                state = pe_sink_soft_reset();
+                state = pe_sink_soft_reset(cfg);
                 break;
             case PESinkSendSoftReset:
-                state = pe_sink_send_soft_reset();
+                state = pe_sink_send_soft_reset(cfg);
                 break;
             case PESinkSendReject:
-                state = pe_sink_send_reject();
+                state = pe_sink_send_reject(cfg);
                 break;
             case PESinkSourceUnresponsive:
-                state = pe_sink_source_unresponsive();
+                state = pe_sink_source_unresponsive(cfg);
                 break;
             default:
                 /* This is an error.  It really shouldn't happen.  We might
     }
 }
 
-void pdb_pe_run(void)
+void pdb_pe_run(struct pdb_config *cfg)
 {
     pdb_pe_thread = chThdCreateStatic(waPolicyEngine, sizeof(waPolicyEngine),
-            PDB_PRIO_PE, PolicyEngine, NULL);
+            PDB_PRIO_PE, PolicyEngine, cfg);
 }

src/config.c

 #include "pd.h"
 
 
-/* Initialize the location of the configuration array.  PDB_CONFIG_BASE is set
+/* Initialize the location of the configuration array.  PDBS_CONFIG_BASE is set
  * in the Makefile. */
-struct pdb_config *pdb_config_array = (struct pdb_config *) PDB_CONFIG_BASE;
+struct pdbs_config *pdbs_config_array = (struct pdbs_config *) PDBS_CONFIG_BASE;
 
 /* The location of the current configuration object.  NULL if not known or
  * there is no current configuration. */
-struct pdb_config *config_cur = NULL;
+struct pdbs_config *config_cur = NULL;
 
 
-void pdb_config_print(BaseSequentialStream *chp, const struct pdb_config *cfg)
+void pdbs_config_print(BaseSequentialStream *chp, const struct pdbs_config *cfg)
 {
     /* Print the status */
     chprintf(chp, "status: ");
     switch (cfg->status) {
-        case PDB_CONFIG_STATUS_INVALID:
+        case PDBS_CONFIG_STATUS_INVALID:
             chprintf(chp, "in");
             /* fall-through */
-        case PDB_CONFIG_STATUS_VALID:
+        case PDBS_CONFIG_STATUS_VALID:
             chprintf(chp, "valid\r\n");
             break;
-        case PDB_CONFIG_STATUS_EMPTY:
+        case PDBS_CONFIG_STATUS_EMPTY:
             chprintf(chp, "empty\r\n");
             /* Stop early because the rest of the information is meaningless in
              * this case. */
     if (cfg->flags == 0) {
         chprintf(chp, "(none)");
     }
-    if (cfg->flags & PDB_CONFIG_FLAGS_GIVEBACK) {
+    if (cfg->flags & PDBS_CONFIG_FLAGS_GIVEBACK) {
         chprintf(chp, "GiveBack ");
     }
-    if (cfg->flags & PDB_CONFIG_FLAGS_VAR_BAT) {
+    if (cfg->flags & PDBS_CONFIG_FLAGS_VAR_BAT) {
         chprintf(chp, "Var/Bat ");
     }
     chprintf(chp, "\r\n");
     /* Print voltages and current */
     chprintf(chp, "v: %d.%02d V\r\n", PD_PDV_V(cfg->v), PD_PDV_CV(cfg->v));
     chprintf(chp, "i: %d.%02d A\r\n", PD_PDI_A(cfg->i), PD_PDI_CA(cfg->i));
-    if (cfg->flags & PDB_CONFIG_FLAGS_VAR_BAT) {
+    if (cfg->flags & PDBS_CONFIG_FLAGS_VAR_BAT) {
         chprintf(chp, "v_min: %d.%02d V\r\n", PD_PDV_V(cfg->v_min),
                  PD_PDV_CV(cfg->v_min));
         chprintf(chp, "v_max: %d.%02d V\r\n", PD_PDV_V(cfg->v_max),
     /* Set the PER bit in the FLASH_CR register to enable page erasing */
     FLASH->CR |= FLASH_CR_PER;
     /* Program the FLASH_AR register to select a page to erase */
-    FLASH->AR = (int) pdb_config_array;
+    FLASH->AR = (int) pdbs_config_array;
     /* Set the STRT bit in the FLASH_CR register to start the erasing */
     FLASH->CR |= FLASH_CR_STRT;
     /* Wait till no operation is on going */
     FLASH->CR &= ~FLASH_CR_PER;
 }
 
-void pdb_config_flash_erase(void)
+void pdbs_config_flash_erase(void)
 {
     /* Enter a critical zone */
     chSysLock();
     chSysUnlock();
 }
 
-void pdb_config_flash_update(const struct pdb_config *cfg)
+void pdbs_config_flash_update(const struct pdbs_config *cfg)
 {
     /* Enter a critical zone */
     chSysLock();
     flash_unlock();
 
     /* If there is an old entry, invalidate it. */
-    struct pdb_config *old = pdb_config_flash_read();
+    struct pdbs_config *old = pdbs_config_flash_read();
     if (old != NULL) {
-        flash_write_halfword(&(old->status), PDB_CONFIG_STATUS_INVALID);
+        flash_write_halfword(&(old->status), PDBS_CONFIG_STATUS_INVALID);
     }
 
     /* Find the first empty entry */
-    struct pdb_config *empty = NULL;
-    for (int i = 0; i < PDB_CONFIG_ARRAY_LEN; i++) {
+    struct pdbs_config *empty = NULL;
+    for (int i = 0; i < PDBS_CONFIG_ARRAY_LEN; i++) {
         /* If we've found it, return it. */
-        if (pdb_config_array[i].status == PDB_CONFIG_STATUS_EMPTY) {
-            empty = &pdb_config_array[i];
+        if (pdbs_config_array[i].status == PDBS_CONFIG_STATUS_EMPTY) {
+            empty = &pdbs_config_array[i];
             break;
         }
     }
     if (empty == NULL) {
         flash_erase();
         /* Write to the first element */
-        empty = &pdb_config_array[0];
+        empty = &pdbs_config_array[0];
     }
 
     /* Write the new configuration */
     chSysUnlock();
 }
 
-struct pdb_config *pdb_config_flash_read(void)
+struct pdbs_config *pdbs_config_flash_read(void)
 {
     /* If we already know where the configuration is, return its location */
     if (config_cur != NULL) {
      * need to find it and store its location if applicable. */
 
     /* If the first element is empty, there is no valid structure. */
-    if (pdb_config_array[0].status == PDB_CONFIG_STATUS_EMPTY) {
+    if (pdbs_config_array[0].status == PDBS_CONFIG_STATUS_EMPTY) {
         return NULL;
     }
 
     /* Find the valid structure, if there is one. */
-    for (int i = 0; i < PDB_CONFIG_ARRAY_LEN; i++) {
+    for (int i = 0; i < PDBS_CONFIG_ARRAY_LEN; i++) {
         /* If we've found it, return it. */
-        if (pdb_config_array[i].status == PDB_CONFIG_STATUS_VALID) {
-            config_cur = &pdb_config_array[i];
+        if (pdbs_config_array[i].status == PDBS_CONFIG_STATUS_VALID) {
+            config_cur = &pdbs_config_array[i];
             return config_cur;
         }
     }

src/config.h

 /*
  * PD Buddy Sink configuration structure
  */
-struct pdb_config {
+struct pdbs_config {
     uint16_t status;
     uint16_t flags;
     uint16_t v;
  * ready to be written, including a status update to VALID.  Once the struct is
  * no longer needed, the status is updated to INVALID.  Erasing the flash page
  * resets all structures to EMPTY. */
-#define PDB_CONFIG_STATUS_INVALID 0x0000
-#define PDB_CONFIG_STATUS_VALID 0xBEEF
-#define PDB_CONFIG_STATUS_EMPTY 0xFFFF
+#define PDBS_CONFIG_STATUS_INVALID 0x0000
+#define PDBS_CONFIG_STATUS_VALID 0xBEEF
+#define PDBS_CONFIG_STATUS_EMPTY 0xFFFF
 
 /* Flags for configuration structures. */
 /* GiveBack supported */
-#define PDB_CONFIG_FLAGS_GIVEBACK 0x0001
+#define PDBS_CONFIG_FLAGS_GIVEBACK 0x0001
 /* Variable and battery PDOs supported (v_min and v_max valid) */
-#define PDB_CONFIG_FLAGS_VAR_BAT 0x0002
+#define PDBS_CONFIG_FLAGS_VAR_BAT 0x0002
 
 
 /* Flash configuration array */
-extern struct pdb_config *pdb_config_array;
+extern struct pdbs_config *pdbs_config_array;
 
 /* The number of elements in the pdb_config_array */
-#define PDB_CONFIG_ARRAY_LEN 128
+#define PDBS_CONFIG_ARRAY_LEN 128
 
 
 /*
  * Print a struct pdb_config to the given BaseSequentialStream
  */
-void pdb_config_print(BaseSequentialStream *chp, const struct pdb_config *cfg);
+void pdbs_config_print(BaseSequentialStream *chp, const struct pdbs_config *cfg);
 
 /*
  * Erase the flash page used for configuration
  */
-void pdb_config_flash_erase(void);
+void pdbs_config_flash_erase(void);
 
 /*
  * Write a configuration structure to flash, invalidating the previous
  * configuration.  If necessary, the flash page is erased before writing the
  * new structure.
  */
-void pdb_config_flash_update(const struct pdb_config *cfg);
+void pdbs_config_flash_update(const struct pdbs_config *cfg);
 
 /*
  * Get the first valid configuration strucure.  If the flash page is empty,
  * lookup is only performed the first time this function is called, so there's
  * very little penalty to calling it repeatedly.
  */
-struct pdb_config *pdb_config_flash_read(void);
+struct pdbs_config *pdbs_config_flash_read(void);
 
 
 #endif /* PDB_CONFIG_H */

src/device_policy_manager.c

 /* The requested voltage */
 static int dpm_requested_voltage;
 
-bool pdb_dpm_evaluate_capability(const union pd_msg *capabilities, union pd_msg *request)
+/* Whether our capabilities matched or not */
+static bool dpm_capability_match;
+
+bool pdbs_dpm_evaluate_capability(struct pdb_config *cfg,
+        const union pd_msg *capabilities, union pd_msg *request)
 {
     /* Update the stored Source_Capabilities */
     if (capabilities != NULL) {
     }
 
     /* Get the current configuration */
-    struct pdb_config *cfg = pdb_config_flash_read();
+    struct pdbs_config *scfg = pdbs_config_flash_read();
     /* Get the number of PDOs */
     uint8_t numobj = PD_NUMOBJ_GET(capabilities);
 
     dpm_unconstrained_power = capabilities->obj[0] & PD_PDO_SRC_FIXED_UNCONSTRAINED;
 
     /* Make sure we have configuration */
-    if (cfg != NULL && pdb_dpm_output_enabled) {
+    if (scfg != NULL && pdb_dpm_output_enabled) {
         /* 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
             }
             /* If the V from the PDO equals our desired V and the I is at least
              * our desired I */
-            if (PD_PDO_SRC_FIXED_VOLTAGE_GET(capabilities, i) == cfg->v
-                    && PD_PDO_SRC_FIXED_CURRENT_GET(capabilities, i) >= cfg->i) {
+            if (PD_PDO_SRC_FIXED_VOLTAGE_GET(capabilities, i) == scfg->v
+                    && PD_PDO_SRC_FIXED_CURRENT_GET(capabilities, i) >= scfg->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);
-                if (cfg->flags & PDB_CONFIG_FLAGS_GIVEBACK) {
+                if (scfg->flags & PDBS_CONFIG_FLAGS_GIVEBACK) {
                     /* GiveBack enabled */
                     request->obj[0] = PD_RDO_FV_MIN_CURRENT_SET(DPM_MIN_CURRENT)
-                        | PD_RDO_FV_CURRENT_SET(cfg->i)
+                        | PD_RDO_FV_CURRENT_SET(scfg->i)
                         | PD_RDO_NO_USB_SUSPEND | PD_RDO_GIVEBACK
                         | PD_RDO_OBJPOS_SET(i + 1);
                 } else {
                     /* GiveBack disabled */
-                    request->obj[0] = PD_RDO_FV_MAX_CURRENT_SET(cfg->i)
-                        | PD_RDO_FV_CURRENT_SET(cfg->i)
+                    request->obj[0] = PD_RDO_FV_MAX_CURRENT_SET(scfg->i)
+                        | PD_RDO_FV_CURRENT_SET(scfg->i)
                         | PD_RDO_NO_USB_SUSPEND | PD_RDO_OBJPOS_SET(i + 1);
                 }
                 if (pdb_dpm_usb_comms) {
                 }
 
                 /* Update requested voltage */
-                dpm_requested_voltage = cfg->v;
+                dpm_requested_voltage = scfg->v;
 
+                dpm_capability_match = true;
                 return true;
             }
         }
     dpm_requested_voltage = PD_MV2PDV(5000);
 
     /* At this point, we have a capability match iff the output is disabled */
+    dpm_capability_match = !pdb_dpm_output_enabled;
     return !pdb_dpm_output_enabled;
 }
 
-void pdb_dpm_get_sink_capability(union pd_msg *cap)
+void pdbs_dpm_get_sink_capability(struct pdb_config *cfg, union pd_msg *cap)
 {
     /* Keep track of how many PDOs we've added */
     int numobj = 0;
     /* Get the current configuration */
-    struct pdb_config *cfg = pdb_config_flash_read();
+    struct pdbs_config *scfg = pdbs_config_flash_read();
 
     /* If we have no configuration or want something other than 5 V, add a PDO
      * for vSafe5V */
-    if (cfg == NULL || cfg->v != PD_MV2PDV(5000)) {
+    if (scfg == NULL || scfg->v != PD_MV2PDV(5000)) {
         /* Minimum current, 5 V, and higher capability. */
         cap->obj[numobj++] = PD_PDO_TYPE_FIXED
             | PD_PDO_SNK_FIXED_VOLTAGE_SET(PD_MV2PDV(5000))
     }
 
     /* Add a PDO for the desired power. */
-    if (cfg != NULL) {
+    if (scfg != NULL) {
         cap->obj[numobj++] = PD_PDO_TYPE_FIXED
-            | PD_PDO_SNK_FIXED_VOLTAGE_SET(cfg->v)
-            | PD_PDO_SNK_FIXED_CURRENT_SET(cfg->i);
+            | PD_PDO_SNK_FIXED_VOLTAGE_SET(scfg->v)
+            | PD_PDO_SNK_FIXED_CURRENT_SET(scfg->i);
         /* If we want more than 5 V, set the Higher Capability flag */
-        if (cfg->v != PD_MV2PDV(5000)) {
+        if (scfg->v != PD_MV2PDV(5000)) {
             cap->obj[0] |= PD_PDO_SNK_FIXED_HIGHER_CAP;
         }
     }
         | PD_POWERROLE_SINK | PD_NUMOBJ(numobj);
 }
 
-bool pdb_dpm_giveback_enabled(void)
+bool pdbs_dpm_giveback_enabled(struct pdb_config *cfg)
 {
-    struct pdb_config *cfg = pdb_config_flash_read();
+    struct pdbs_config *scfg = pdbs_config_flash_read();
 
-    return cfg->flags & PDB_CONFIG_FLAGS_GIVEBACK;
+    return scfg->flags & PDBS_CONFIG_FLAGS_GIVEBACK;
 }
 
-bool pdb_dpm_evaluate_typec_current(enum fusb_typec_current tcc)
+bool pdbs_dpm_evaluate_typec_current(struct pdb_config *cfg,
+        enum fusb_typec_current tcc)
 {
-    struct pdb_config *cfg = pdb_config_flash_read();
+    struct pdbs_config *scfg = pdbs_config_flash_read();
 
     /* We don't control the voltage anymore; it will always be 5 V. */
     dpm_requested_voltage = PD_MV2PDV(5000);
 
     /* If we have no configuration or don't want 5 V, Type-C Current can't
      * possibly satisfy our needs */
-    if (cfg == NULL || cfg->v != PD_MV2PDV(5000)) {
+    if (scfg == NULL || scfg->v != PD_MV2PDV(5000)) {
+        dpm_capability_match = false;
         return false;
     }
 
     /* If 1.5 A is available and we want no more than that, great. */
-    if (tcc == OnePointFiveAmps && cfg->i <= 150) {
+    if (tcc == OnePointFiveAmps && scfg->i <= 150) {
+        dpm_capability_match = true;
         return true;
     }
     /* If 3 A is available and we want no more than that, that's great too. */
-    if (tcc == ThreePointZeroAmps && cfg->i <= 300) {
+    if (tcc == ThreePointZeroAmps && scfg->i <= 300) {
+        dpm_capability_match = true;
         return true;
     }
     /* We're overly cautious if USB default current is available, since that
      * and since we're really supposed to enumerate in order to request more
      * than 100 mA.  This could be changed in the future. */
 
+    dpm_capability_match = false;
     return false;
 }
 
-void pdb_dpm_pd_start(void)
+void pdbs_dpm_pd_start(struct pdb_config *cfg)
 {
     if (pdb_dpm_led_pd_status) {
         chEvtSignal(pdb_led_thread, PDB_EVT_LED_NEGOTIATING);
     }
 }
 
-void pdb_dpm_sink_standby(void)
-{
-    /* If the voltage is changing, enter Sink Standby */
-    if (dpm_requested_voltage != dpm_present_voltage) {
-        /* For the PD Buddy Sink, entering Sink Standby is equivalent to
-         * turning the output off.  However, we don't want to change the LED
-         * state for standby mode. */
-        palClearLine(LINE_OUT_CTRL);
-    }
-}
-
-void pdb_dpm_output_set(bool state)
+/*
+ * Set the output state, with LED indication.
+ */
+static void dpm_output_set(bool state)
 {
     /* Update the present voltage */
     dpm_present_voltage = dpm_requested_voltage;
     }
 }
 
-void pdb_dpm_output_default(void)
+void pdbs_dpm_transition_default(struct pdb_config *cfg)
 {
     /* Pretend we requested 5 V */
     dpm_requested_voltage = PD_MV2PDV(5000);
     /* Turn the output off */
-    pdb_dpm_output_set(false);
+    dpm_output_set(false);
+}
+
+void pdbs_dpm_transition_min(struct pdb_config *cfg)
+{
+    dpm_output_set(false);
+}
+
+void pdbs_dpm_transition_standby(struct pdb_config *cfg)
+{
+    /* If the voltage is changing, enter Sink Standby */
+    if (dpm_requested_voltage != dpm_present_voltage) {
+        /* For the PD Buddy Sink, entering Sink Standby is equivalent to
+         * turning the output off.  However, we don't want to change the LED
+         * state for standby mode. */
+        palClearLine(LINE_OUT_CTRL);
+    }
+}
+
+void pdbs_dpm_transition_requested(struct pdb_config *cfg)
+{
+    dpm_output_set(dpm_capability_match);
 }

src/device_policy_manager.h

 
 #include <stdbool.h>
 
+#include <pdb.h>
 #include "fusb302b.h"
 #include "messages.h"
 
  *
  * Returns true if sufficient power is available, false otherwise.
  */
-bool pdb_dpm_evaluate_capability(const union pd_msg *capabilities, union pd_msg *request);
+bool pdbs_dpm_evaluate_capability(struct pdb_config *cfg,
+        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);
+void pdbs_dpm_get_sink_capability(struct pdb_config *cfg, union pd_msg *cap);
 
 /*
  * Return whether or not GiveBack support is enabled.
  */
-bool pdb_dpm_giveback_enabled(void);
+bool pdbs_dpm_giveback_enabled(struct pdb_config *cfg);
 
 /*
  * Evaluate whether or not the currently offered Type-C Current can fulfill our
  *
  * Returns true if sufficient power is available, false otherwise.
  */
-bool pdb_dpm_evaluate_typec_current(enum fusb_typec_current tcc);
+bool pdbs_dpm_evaluate_typec_current(struct pdb_config *cfg, enum fusb_typec_current tcc);
 
 /*
  * Indicate that power negotiations are starting.
  */
-void pdb_dpm_pd_start(void);
+void pdbs_dpm_pd_start(struct pdb_config *cfg);
 
 /*
- * Transition to Sink Standby if necessary.
+ * Transition the sink to default power.
  */
-void pdb_dpm_sink_standby(void);
+void pdbs_dpm_transition_default(struct pdb_config *cfg);
 
 /*
- * Set the output state, with LED indication.
+ * Transition to the requested minimum current.
  */
-void pdb_dpm_output_set(bool state);
+void pdbs_dpm_transition_min(struct pdb_config *cfg);
 
 /*
- * Transition the sink to default power.
+ * Transition to Sink Standby if necessary.
+ */
+void pdbs_dpm_transition_standby(struct pdb_config *cfg);
+
+/*
+ * Transition to the requested power level
  */
-void pdb_dpm_output_default(void);
+void pdbs_dpm_transition_requested(struct pdb_config *cfg);
 
 
 #endif /* PDB_DEVICE_POLICY_MANAGER_H */

src/main.c

     0
 };
 
+/*
+ * PD Buddy firmware library configuration object
+ */
+static struct pdb_config pdb_config = {
+    .fusb = {
+        &I2CD2,
+        FUSB302B_ADDR
+    },
+    .dpm = {
+        pdbs_dpm_evaluate_capability,
+        pdbs_dpm_get_sink_capability,
+        pdbs_dpm_giveback_enabled,
+        pdbs_dpm_evaluate_typec_current,
+        pdbs_dpm_pd_start,
+        pdbs_dpm_transition_default,
+        pdbs_dpm_transition_min,
+        pdbs_dpm_transition_standby,
+        pdbs_dpm_transition_requested,
+        pdbs_dpm_transition_requested /* XXX type-c current */
+    }
+};
+
 /*
  * Enter setup mode
  */
     pdb_dpm_usb_comms = true;
 
     /* Start the USB Power Delivery threads */
-    pdb_init();
+    pdb_init(&pdb_config);
 
     /* Indicate that we're in setup mode */
     chEvtSignal(pdb_led_thread, PDB_EVT_LED_CONFIG);
 static void sink(void)
 {
     /* Start the USB Power Delivery threads */
-    pdb_init();
+    pdb_init(&pdb_config);
 
     /* Wait, letting all the other threads do their work. */
     while (true) {

src/shell.c

 
 
 /* Buffer for unwritten configuration */
-static struct pdb_config tmpcfg = {
-    .status = PDB_CONFIG_STATUS_VALID
+static struct pdbs_config tmpcfg = {
+    .status = PDBS_CONFIG_STATUS_VALID
 };
 
 /*
         return;
     }
 
-    pdb_config_flash_erase();
+    pdbs_config_flash_erase();
 }
 
 static void cmd_write(BaseSequentialStream *chp, int argc, char *argv[])
         return;
     }
 
-    pdb_config_flash_update(&tmpcfg);
+    pdbs_config_flash_update(&tmpcfg);
 
     chEvtSignal(pdb_pe_thread, PDB_EVT_PE_NEW_POWER);
 }
     }
 
     /* Get the current configuration */
-    struct pdb_config *cfg = pdb_config_flash_read();
+    struct pdbs_config *cfg = pdbs_config_flash_read();
     if (cfg == NULL) {
         chprintf(chp, "No configuration\r\n");
         return;
 
 static void cmd_get_cfg(BaseSequentialStream *chp, int argc, char *argv[])
 {
-    struct pdb_config *cfg = NULL;
+    struct pdbs_config *cfg = NULL;
 
     if (argc > 1) {
         chprintf(chp, "Usage: get_cfg [index]\r\n");
 
     /* With no arguments, find the current configuration */
     if (argc == 0) {
-        cfg = pdb_config_flash_read();
+        cfg = pdbs_config_flash_read();
         if (cfg == NULL) {
             chprintf(chp, "No configuration\r\n");
             return;
     } else if (argc == 1) {
         char *endptr;
         long i = strtol(argv[0], &endptr, 0);
-        if (i >= 0 && i < PDB_CONFIG_ARRAY_LEN && endptr > argv[0]) {
-            cfg = &pdb_config_array[i];
+        if (i >= 0 && i < PDBS_CONFIG_ARRAY_LEN && endptr > argv[0]) {
+            cfg = &pdbs_config_array[i];
         } else {
             chprintf(chp, "Invalid index\r\n");
             return;
         }
     }
     /* Print the configuration */
-    pdb_config_print(chp, cfg);
+    pdbs_config_print(chp, cfg);
 }
 
 static void cmd_get_tmpcfg(BaseSequentialStream *chp, int argc, char *argv[])
         return;
     }
 
-    pdb_config_print(chp, &tmpcfg);
+    pdbs_config_print(chp, &tmpcfg);
 }
 
 static void cmd_clear_flags(BaseSequentialStream *chp, int argc, char *argv[])
     }
 
     /* Toggle the GiveBack flag */
-    tmpcfg.flags ^= PDB_CONFIG_FLAGS_GIVEBACK;
+    tmpcfg.flags ^= PDBS_CONFIG_FLAGS_GIVEBACK;
 }
 
 static void cmd_set_v(BaseSequentialStream *chp, int argc, char *argv[])