Use a struct pdbs_dpm_data for DPM globals

Not the static globals yet, just the public ones.  I suppose this change
isn't technically necessary since the PD Buddy Sink is a single-port
device, but I want its firmware to be a shining example of how to use
the library.

lib/include/pdb_pe.h

 
 
 struct pdb_pe {
-    THD_WORKING_AREA(_wa, 128);
+    THD_WORKING_AREA(_wa, 256);
     thread_t *thread;
 
     /* PE mailbox for received PD messages */

src/device_policy_manager.c

 #include "pd.h"
 
 
-bool pdb_dpm_output_enabled = true;
-bool pdb_dpm_led_pd_status = true;
-bool pdb_dpm_usb_comms = false;
-
-const union pd_msg *pdb_dpm_capabilities = NULL;
-enum fusb_typec_current pdb_dpm_typec_current = None;
-
-
 /* The current draw when the output is disabled */
 #define DPM_MIN_CURRENT PD_MA2PDI(100)
 
 bool pdbs_dpm_evaluate_capability(struct pdb_config *cfg,
         const union pd_msg *capabilities, union pd_msg *request)
 {
+    /* Cast the dpm_data to the right type */
+    struct pdbs_dpm_data *dpm_data = cfg->dpm_data;
+
     /* Update the stored Source_Capabilities */
     if (capabilities != NULL) {
-        if (pdb_dpm_capabilities != NULL) {
-            chPoolFree(&pdb_msg_pool, (union pd_msg *) pdb_dpm_capabilities);
+        if (dpm_data->capabilities != NULL) {
+            chPoolFree(&pdb_msg_pool, (union pd_msg *) dpm_data->capabilities);
         }
-        pdb_dpm_capabilities = capabilities;
+        dpm_data->capabilities = capabilities;
     } else {
         /* No new capabilities; use a shorter name for the stored ones. */
-        capabilities = pdb_dpm_capabilities;
+        capabilities = dpm_data->capabilities;
     }
 
     /* Get the current configuration */
     uint8_t numobj = PD_NUMOBJ_GET(capabilities);
 
     /* Make the LED blink to indicate ongoing power negotiations */
-    if (pdb_dpm_led_pd_status) {
+    if (dpm_data->led_pd_status) {
         chEvtSignal(pdbs_led_thread, PDBS_EVT_LED_NEGOTIATING);
     }
 
     dpm_unconstrained_power = capabilities->obj[0] & PD_PDO_SRC_FIXED_UNCONSTRAINED;
 
     /* Make sure we have configuration */
-    if (scfg != NULL && pdb_dpm_output_enabled) {
+    if (scfg != NULL && dpm_data->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
                         | PD_RDO_FV_CURRENT_SET(scfg->i)
                         | PD_RDO_NO_USB_SUSPEND | PD_RDO_OBJPOS_SET(i + 1);
                 }
-                if (pdb_dpm_usb_comms) {
+                if (dpm_data->usb_comms) {
                     request->obj[0] |= PD_RDO_USB_COMMS;
                 }
 
         | PD_RDO_OBJPOS_SET(1);
     /* If the output is enabled and we got here, it must be a capability
      * mismatch. */
-    if (pdb_dpm_output_enabled) {
+    if (dpm_data->output_enabled) {
         request->obj[0] |= PD_RDO_CAP_MISMATCH;
     }
     /* If we can do USB communications, tell the power supply */
-    if (pdb_dpm_usb_comms) {
+    if (dpm_data->usb_comms) {
         request->obj[0] |= PD_RDO_USB_COMMS;
     }
 
     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;
+    dpm_capability_match = !dpm_data->output_enabled;
+    return !dpm_data->output_enabled;
 }
 
 void pdbs_dpm_get_sink_capability(struct pdb_config *cfg, union pd_msg *cap)
     int numobj = 0;
     /* Get the current configuration */
     struct pdbs_config *scfg = pdbs_config_flash_read();
+    /* Cast the dpm_data to the right type */
+    struct pdbs_dpm_data *dpm_data = cfg->dpm_data;
 
     /* If we have no configuration or want something other than 5 V, add a PDO
      * for vSafe5V */
     }
 
     /* Set the USB communications capable flag. */
-    if (pdb_dpm_usb_comms) {
+    if (dpm_data->usb_comms) {
         cap->obj[0] |= PD_PDO_SNK_FIXED_USB_COMMS;
     }
 
         enum fusb_typec_current tcc)
 {
     struct pdbs_config *scfg = pdbs_config_flash_read();
+    /* Cast the dpm_data to the right type */
+    struct pdbs_dpm_data *dpm_data = cfg->dpm_data;
 
     /* We don't control the voltage anymore; it will always be 5 V. */
     dpm_requested_voltage = PD_MV2PDV(5000);
 
     /* Make the present Type-C Current advertisement available to the rest of
      * the DPM */
-    pdb_dpm_typec_current = tcc;
+    dpm_data->typec_current = tcc;
 
     /* If we have no configuration or don't want 5 V, Type-C Current can't
      * possibly satisfy our needs */
 
 void pdbs_dpm_pd_start(struct pdb_config *cfg)
 {
-    if (pdb_dpm_led_pd_status) {
+    /* Cast the dpm_data to the right type */
+    struct pdbs_dpm_data *dpm_data = cfg->dpm_data;
+
+    if (dpm_data->led_pd_status) {
         chEvtSignal(pdbs_led_thread, PDBS_EVT_LED_NEGOTIATING);
     }
 }
 /*
  * Set the output state, with LED indication.
  */
-static void dpm_output_set(bool state)
+static void dpm_output_set(struct pdbs_dpm_data *dpm_data, bool state)
 {
     /* Update the present voltage */
     dpm_present_voltage = dpm_requested_voltage;
 
     /* Set the power output */
-    if (state && pdb_dpm_output_enabled) {
+    if (state && dpm_data->output_enabled) {
         /* Turn the output on */
-        if (pdb_dpm_led_pd_status) {
+        if (dpm_data->led_pd_status) {
             chEvtSignal(pdbs_led_thread, PDBS_EVT_LED_OUTPUT_ON);
         }
         palSetLine(LINE_OUT_CTRL);
     } else {
         /* Turn the output off */
-        if (pdb_dpm_led_pd_status) {
+        if (dpm_data->led_pd_status) {
             chEvtSignal(pdbs_led_thread, PDBS_EVT_LED_OUTPUT_OFF);
         }
         palClearLine(LINE_OUT_CTRL);
     /* Pretend we requested 5 V */
     dpm_requested_voltage = PD_MV2PDV(5000);
     /* Turn the output off */
-    dpm_output_set(false);
+    dpm_output_set(cfg->dpm_data, false);
 }
 
 void pdbs_dpm_transition_min(struct pdb_config *cfg)
 {
-    dpm_output_set(false);
+    dpm_output_set(cfg->dpm_data, false);
 }
 
 void pdbs_dpm_transition_standby(struct pdb_config *cfg)
 
 void pdbs_dpm_transition_requested(struct pdb_config *cfg)
 {
-    dpm_output_set(dpm_capability_match);
+    dpm_output_set(cfg->dpm_data, dpm_capability_match);
 }

src/device_policy_manager.h

 #include "messages.h"
 
 
-/* Whether the DPM is able to turn on the output */
-extern bool pdb_dpm_output_enabled;
-
-/* Whether the DPM sets the LED to indicate the PD status */
-extern bool pdb_dpm_led_pd_status;
-
-/* Whether the device is capable of USB communications */
-extern bool pdb_dpm_usb_comms;
-
-/* The most recently received Source_Capabilities message */
-extern const union pd_msg *pdb_dpm_capabilities;
-
-/* The most recently received Type-C Current advertisement */
-extern enum fusb_typec_current pdb_dpm_typec_current;
+struct pdbs_dpm_data {
+    /* The most recently received Source_Capabilities message */
+    const union pd_msg *capabilities;
+    /* The most recently received Type-C Current advertisement */
+    enum fusb_typec_current typec_current;
+    /* Whether the DPM is able to turn on the output */
+    bool output_enabled;
+    /* Whether the DPM sets the LED to indicate the PD status */
+    bool led_pd_status;
+    /* Whether the device is capable of USB communications */
+    bool usb_comms;
+};
 
 
 /*

src/main.c

     0
 };
 
+/*
+ * PD Buddy Sink DPM data
+ */
+static struct pdbs_dpm_data dpm_data = {
+    NULL,
+    None,
+    true,
+    true,
+    false
+};
+
 /*
  * PD Buddy firmware library configuration object
  */
         pdbs_dpm_transition_standby,
         pdbs_dpm_transition_requested,
         pdbs_dpm_transition_requested /* XXX type-c current */
-    }
+    },
+    .dpm_data = &dpm_data
 };
 
 /*
 static void setup(void)
 {
     /* Configure the DPM to play nice with the shell */
-    pdb_dpm_output_enabled = false;
-    pdb_dpm_led_pd_status = false;
-    pdb_dpm_usb_comms = true;
+    dpm_data.output_enabled = false;
+    dpm_data.led_pd_status = false;
+    dpm_data.usb_comms = true;
 
     /* Start the USB Power Delivery threads */
     pdb_init(&pdb_config);

src/shell.c

 
 /* Pointer to the PD Buddy firmware library configuration */
 static struct pdb_config *pdb_config;
+static struct pdbs_dpm_data *pdbs_dpm_data;
 
 /*
  * Helper functions for printing PDOs
 {
     if (argc == 0) {
         /* With no arguments, print the output status */
-        if (pdb_dpm_output_enabled) {
+        if (pdbs_dpm_data->output_enabled) {
             chprintf(chp, "enabled\r\n");
         } else {
             chprintf(chp, "disabled\r\n");
     } else if (argc == 1) {
         /* Set the output status and re-negotiate power */
         if (strcmp(argv[0], "enable") == 0) {
-            pdb_dpm_output_enabled = true;
+            pdbs_dpm_data->output_enabled = true;
             chEvtSignal(pdb_config->pe.thread, PDB_EVT_PE_NEW_POWER);
         } else if (strcmp(argv[0], "disable") == 0) {
-            pdb_dpm_output_enabled = false;
+            pdbs_dpm_data->output_enabled = false;
             chEvtSignal(pdb_config->pe.thread, PDB_EVT_PE_NEW_POWER);
         } else {
             /* Or, if the argument was invalid, print a usage message */
     }
 
     /* If we haven't seen any Source_Capabilities */
-    if (pdb_dpm_capabilities == NULL) {
+    if (pdbs_dpm_data->capabilities == NULL) {
         /* Have we started reading Type-C Current advertisements? */
-        if (pdb_dpm_typec_current != None) {
+        if (pdbs_dpm_data->typec_current != None) {
             /* Type-C Current is available, so report it */
             chprintf(chp, "PDO 1: typec_virtual\r\n");
-            if (pdb_dpm_typec_current == Default) {
+            if (pdbs_dpm_data->typec_current == Default) {
                 chprintf(chp, "\ti: 0.50 A\r\n");
-            } else if (pdb_dpm_typec_current == OnePointFiveAmps) {
+            } else if (pdbs_dpm_data->typec_current == OnePointFiveAmps) {
                 chprintf(chp, "\ti: 1.50 A\r\n");
-            } else if (pdb_dpm_typec_current == ThreePointZeroAmps) {
+            } else if (pdbs_dpm_data->typec_current == ThreePointZeroAmps) {
                 chprintf(chp, "\ti: 3.00 A\r\n");
             }
             return;
     }
 
     /* Print all the PDOs */
-    uint8_t numobj = PD_NUMOBJ_GET(pdb_dpm_capabilities);
+    uint8_t numobj = PD_NUMOBJ_GET(pdbs_dpm_data->capabilities);
     for (uint8_t i = 0; i < numobj; i++) {
-        print_src_pdo(chp, pdb_dpm_capabilities->obj[i], i+1);
+        print_src_pdo(chp, pdbs_dpm_data->capabilities->obj[i], i+1);
     }
 }
 
     char *args[PDB_SHELL_MAX_ARGUMENTS + 1];
 
     pdb_config = cfg;
+    pdbs_dpm_data = cfg->dpm_data;
 
     while (true) {
         /* Print the prompt */