Use struct pdbs_dpm_data for DPM private variables

Again, shining example and whatnot.

src/device_policy_manager.c

 /* The current draw when the output is disabled */
 #define DPM_MIN_CURRENT PD_MA2PDI(100)
 
-/* Whether or not the power supply is unconstrained */
-static bool dpm_unconstrained_power;
-
-/* The last explicitly or implicitly negotiated voltage in PDV */
-static int dpm_present_voltage = PD_MV2PDV(5000);
-
-/* The requested voltage */
-static int dpm_requested_voltage;
-
-/* 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)
 {
     }
 
     /* Get whether or not the power supply is constrained */
-    dpm_unconstrained_power = capabilities->obj[0] & PD_PDO_SRC_FIXED_UNCONSTRAINED;
+    dpm_data->_unconstrained_power = capabilities->obj[0] & PD_PDO_SRC_FIXED_UNCONSTRAINED;
 
     /* Make sure we have configuration */
     if (scfg != NULL && dpm_data->output_enabled) {
                 }
 
                 /* Update requested voltage */
-                dpm_requested_voltage = scfg->v;
+                dpm_data->_requested_voltage = scfg->v;
 
-                dpm_capability_match = true;
+                dpm_data->_capability_match = true;
                 return true;
             }
         }
     }
 
     /* Update requested voltage */
-    dpm_requested_voltage = PD_MV2PDV(5000);
+    dpm_data->_requested_voltage = PD_MV2PDV(5000);
 
     /* At this point, we have a capability match iff the output is disabled */
-    dpm_capability_match = !dpm_data->output_enabled;
+    dpm_data->_capability_match = !dpm_data->output_enabled;
     return !dpm_data->output_enabled;
 }
 
     }
 
     /* Set the unconstrained power flag. */
-    if (dpm_unconstrained_power) {
+    if (dpm_data->_unconstrained_power) {
         cap->obj[0] |= PD_PDO_SNK_FIXED_UNCONSTRAINED;
     }
 
     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);
+    dpm_data->_requested_voltage = PD_MV2PDV(5000);
 
     /* Make the present Type-C Current advertisement available to the rest of
      * the DPM */
     /* If we have no configuration or don't want 5 V, Type-C Current can't
      * possibly satisfy our needs */
     if (scfg == NULL || scfg->v != PD_MV2PDV(5000)) {
-        dpm_capability_match = false;
+        dpm_data->_capability_match = false;
         return false;
     }
 
     /* If 1.5 A is available and we want no more than that, great. */
     if (tcc == OnePointFiveAmps && scfg->i <= 150) {
-        dpm_capability_match = true;
+        dpm_data->_capability_match = true;
         return true;
     }
     /* If 3 A is available and we want no more than that, that's great too. */
     if (tcc == ThreePointZeroAmps && scfg->i <= 300) {
-        dpm_capability_match = true;
+        dpm_data->_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;
+    dpm_data->_capability_match = false;
     return false;
 }
 
 static void dpm_output_set(struct pdbs_dpm_data *dpm_data, bool state)
 {
     /* Update the present voltage */
-    dpm_present_voltage = dpm_requested_voltage;
+    dpm_data->_present_voltage = dpm_data->_requested_voltage;
 
     /* Set the power output */
     if (state && dpm_data->output_enabled) {
 
 void pdbs_dpm_transition_default(struct pdb_config *cfg)
 {
+    /* Cast the dpm_data to the right type */
+    struct pdbs_dpm_data *dpm_data = cfg->dpm_data;
+
     /* Pretend we requested 5 V */
-    dpm_requested_voltage = PD_MV2PDV(5000);
+    dpm_data->_requested_voltage = PD_MV2PDV(5000);
     /* Turn the output off */
     dpm_output_set(cfg->dpm_data, false);
 }
 
 void pdbs_dpm_transition_standby(struct pdb_config *cfg)
 {
+    /* Cast the dpm_data to the right type */
+    struct pdbs_dpm_data *dpm_data = cfg->dpm_data;
+
     /* If the voltage is changing, enter Sink Standby */
-    if (dpm_requested_voltage != dpm_present_voltage) {
+    if (dpm_data->_requested_voltage != dpm_data->_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. */
 
 void pdbs_dpm_transition_requested(struct pdb_config *cfg)
 {
-    dpm_output_set(cfg->dpm_data, dpm_capability_match);
+    /* Cast the dpm_data to the right type */
+    struct pdbs_dpm_data *dpm_data = cfg->dpm_data;
+
+    dpm_output_set(cfg->dpm_data, dpm_data->_capability_match);
 }

src/device_policy_manager.h

     bool led_pd_status;
     /* Whether the device is capable of USB communications */
     bool usb_comms;
+
+    /* Whether or not the power supply is unconstrained */
+    bool _unconstrained_power;
+    /* Whether our capabilities matched or not */
+    bool _capability_match;
+    /* The last explicitly or implicitly negotiated voltage in PDV */
+    int _present_voltage;
+    /* The requested voltage */
+    int _requested_voltage;
 };
 
 

src/main.c

 #include <pdb.h>
 #include "led.h"
 #include "device_policy_manager.h"
+#include "pd.h"
 
 /*
  * I2C configuration object.
     None,
     true,
     true,
-    false
+    false,
+    ._present_voltage = PD_MV2PDV(5000)
 };
 
 /*