Changed PDO getters to take just the PDO

Previously, the PDO attribute getter macros took a capabilities message
and the PDO index.  This worked in a lot of cases, but not in some I
need now, and there was little advantage to them working they way they
did anyway.  Now they take just the PDO itself, which is more intuitive
and more useful.

lib/include/pd.h

 #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)
+#define PD_PDO_SRC_FIXED_CURRENT_GET(pdo) (((pdo) & 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)
+#define PD_PDO_SRC_FIXED_VOLTAGE_GET(pdo) (((pdo) & PD_PDO_SRC_FIXED_VOLTAGE) >> PD_PDO_SRC_FIXED_VOLTAGE_SHIFT)
 
 /* PD Programmable Power Supply APDO */
 #define PD_APDO_PPS_MAX_VOLTAGE_SHIFT 17
 #define PD_APDO_PPS_CURRENT (0x7F << PD_APDO_PPS_CURRENT_SHIFT)
 
 /* PD Programmable Power Supply APDO voltages */
-#define PD_APDO_PPS_MAX_VOLTAGE_GET(msg, i) (((msg)->obj[(i)] & PD_APDO_PPS_MAX_VOLTAGE) >> PD_APDO_PPS_MAX_VOLTAGE_SHIFT)
-#define PD_APDO_PPS_MIN_VOLTAGE_GET(msg, i) (((msg)->obj[(i)] & PD_APDO_PPS_MIN_VOLTAGE) >> PD_APDO_PPS_MIN_VOLTAGE_SHIFT)
+#define PD_APDO_PPS_MAX_VOLTAGE_GET(pdo) (((pdo) & PD_APDO_PPS_MAX_VOLTAGE) >> PD_APDO_PPS_MAX_VOLTAGE_SHIFT)
+#define PD_APDO_PPS_MIN_VOLTAGE_GET(pdo) (((pdo) & PD_APDO_PPS_MIN_VOLTAGE) >> PD_APDO_PPS_MIN_VOLTAGE_SHIFT)
 
 #define PD_APDO_PPS_MAX_VOLTAGE_SET(v) (((v) << PD_APDO_PPS_MAX_VOLTAGE_SHIFT) & PD_APDO_PPS_MAX_VOLTAGE)
 #define PD_APDO_PPS_MIN_VOLTAGE_SET(v) (((v) << PD_APDO_PPS_MIN_VOLTAGE_SHIFT) & PD_APDO_PPS_MIN_VOLTAGE)
 
 /* PD Programmable Power Supply APDO current */
-#define PD_APDO_PPS_CURRENT_GET(msg, i) (((msg)->obj[(i)] & PD_APDO_PPS_CURRENT) >> PD_APDO_PPS_CURRENT_SHIFT)
+#define PD_APDO_PPS_CURRENT_GET(pdo) (((pdo) & PD_APDO_PPS_CURRENT) >> PD_APDO_PPS_CURRENT_SHIFT)
 
 #define PD_APDO_PPS_CURRENT_SET(i) (((i) << PD_APDO_PPS_CURRENT_SHIFT) & PD_APDO_PPS_CURRENT)
 

src/device_policy_manager.c

  *
  * If there is no such PDO, returns -1 instead.
  */
-static int8_t dpm_get_range_fixed_pdo_index(const union pd_msg *capabilities,
+static int8_t dpm_get_range_fixed_pdo_index(const union pd_msg *caps,
         struct pdbs_config *scfg)
 {
     /* Get the number of PDOs */
-    uint8_t numobj = PD_NUMOBJ_GET(capabilities);
+    uint8_t numobj = PD_NUMOBJ_GET(caps);
 
     /* Get ready to iterate over the PDOs */
     int8_t i;
     while (0 <= i && i < numobj) {
         /* If we have a fixed PDO, its V is within our range, and its I is at
          * least our desired I */
-        if ((capabilities->obj[i] & PD_PDO_TYPE) == PD_PDO_TYPE_FIXED
-                && PD_PDO_SRC_FIXED_CURRENT_GET(capabilities, i) >= scfg->i
-                && PD_PDO_SRC_FIXED_VOLTAGE_GET(capabilities, i) >= PD_MV2PDV(scfg->vmin)
-                && PD_PDO_SRC_FIXED_VOLTAGE_GET(capabilities, i) <= PD_MV2PDV(scfg->vmax)) {
+        if ((caps->obj[i] & PD_PDO_TYPE) == PD_PDO_TYPE_FIXED
+                && PD_PDO_SRC_FIXED_CURRENT_GET(caps->obj[i]) >= scfg->i
+                && PD_PDO_SRC_FIXED_VOLTAGE_GET(caps->obj[i]) >= PD_MV2PDV(scfg->vmin)
+                && PD_PDO_SRC_FIXED_VOLTAGE_GET(caps->obj[i]) <= PD_MV2PDV(scfg->vmax)) {
             return i;
         }
         i += step;
 }
 
 bool pdbs_dpm_evaluate_capability(struct pdb_config *cfg,
-        const union pd_msg *capabilities, union pd_msg *request)
+        const union pd_msg *caps, 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 (caps != NULL) {
         if (dpm_data->capabilities != NULL) {
             chPoolFree(&pdb_msg_pool, (union pd_msg *) dpm_data->capabilities);
         }
-        dpm_data->capabilities = capabilities;
+        dpm_data->capabilities = caps;
     } else {
         /* No new capabilities; use a shorter name for the stored ones. */
-        capabilities = dpm_data->capabilities;
+        caps = dpm_data->capabilities;
     }
 
     /* Get the current configuration */
     struct pdbs_config *scfg = pdbs_config_flash_read();
     /* Get the number of PDOs */
-    uint8_t numobj = PD_NUMOBJ_GET(capabilities);
+    uint8_t numobj = PD_NUMOBJ_GET(caps);
 
     /* Make the LED blink to indicate ongoing power negotiations */
     if (dpm_data->led_pd_status) {
     }
 
     /* Get whether or not the power supply is constrained */
-    dpm_data->_unconstrained_power = capabilities->obj[0] & PD_PDO_SRC_FIXED_UNCONSTRAINED;
+    dpm_data->_unconstrained_power = caps->obj[0] & PD_PDO_SRC_FIXED_UNCONSTRAINED;
 
     /* Make sure we have configuration */
     if (scfg != NULL && dpm_data->output_enabled) {
         for (uint8_t i = 0; i < numobj; i++) {
             /* If we have a fixed PDO, its V equals our desired V, and its I is
              * at least our desired I */
-            if ((capabilities->obj[i] & PD_PDO_TYPE) == PD_PDO_TYPE_FIXED
-                    && PD_PDO_SRC_FIXED_VOLTAGE_GET(capabilities, i) == PD_MV2PDV(scfg->v)
-                    && PD_PDO_SRC_FIXED_CURRENT_GET(capabilities, i) >= scfg->i) {
+            if ((caps->obj[i] & PD_PDO_TYPE) == PD_PDO_TYPE_FIXED
+                    && PD_PDO_SRC_FIXED_VOLTAGE_GET(caps->obj[i]) == PD_MV2PDV(scfg->v)
+                    && PD_PDO_SRC_FIXED_CURRENT_GET(caps->obj[i]) >= scfg->i) {
                 /* We got what we wanted, so build a request for that */
                 request->hdr = cfg->pe.hdr_template | PD_MSGTYPE_REQUEST
                     | PD_NUMOBJ(1);
             }
             /* If we have a PPS APDO, our desired V lies within its range, and
              * its I is at least our desired I */
-            if ((capabilities->obj[i] & PD_PDO_TYPE) == PD_PDO_TYPE_AUGMENTED
-                    && (capabilities->obj[i] & PD_APDO_TYPE) == PD_APDO_TYPE_PPS
-                    && PD_APDO_PPS_MAX_VOLTAGE_GET(capabilities, i) >= PD_MV2PAV(scfg->v)
-                    && PD_APDO_PPS_MIN_VOLTAGE_GET(capabilities, i) <= PD_MV2PAV(scfg->v)
-                    && PD_APDO_PPS_CURRENT_GET(capabilities, i) >= PD_CA2PAI(scfg->i)) {
+            if ((caps->obj[i] & PD_PDO_TYPE) == PD_PDO_TYPE_AUGMENTED
+                    && (caps->obj[i] & PD_APDO_TYPE) == PD_APDO_TYPE_PPS
+                    && PD_APDO_PPS_MAX_VOLTAGE_GET(caps->obj[i]) >= PD_MV2PAV(scfg->v)
+                    && PD_APDO_PPS_MIN_VOLTAGE_GET(caps->obj[i]) <= PD_MV2PAV(scfg->v)
+                    && PD_APDO_PPS_CURRENT_GET(caps->obj[i]) >= PD_CA2PAI(scfg->i)) {
                 /* We got what we wanted, so build a request for that */
                 request->hdr = cfg->pe.hdr_template | PD_MSGTYPE_REQUEST
                     | PD_NUMOBJ(1);
             }
         }
         /* If there's a PDO in the voltage range, use it */
-        int8_t i = dpm_get_range_fixed_pdo_index(capabilities, scfg);
+        int8_t i = dpm_get_range_fixed_pdo_index(caps, scfg);
         if (i >= 0) {
             /* We got what we wanted, so build a request for that */
             request->hdr = cfg->pe.hdr_template | PD_MSGTYPE_REQUEST
             }
 
             /* Update requested voltage */
-            dpm_data->_requested_voltage = PD_PDV2MV(PD_PDO_SRC_FIXED_VOLTAGE_GET(capabilities, i));
+            dpm_data->_requested_voltage = PD_PDV2MV(PD_PDO_SRC_FIXED_VOLTAGE_GET(caps->obj[i]));
 
             dpm_data->_capability_match = true;
             return true;
 
             /* If the range PDO is a different voltage than the preferred
              * voltage, add it to the array. */
-            if (i > 0 && PD_PDO_SRC_FIXED_VOLTAGE_GET(dpm_data->capabilities, i) != PD_MV2PDV(scfg->v)) {
+            if (i > 0 && PD_PDO_SRC_FIXED_VOLTAGE_GET(dpm_data->capabilities->obj[i]) != PD_MV2PDV(scfg->v)) {
                 cap->obj[numobj++] = PD_PDO_TYPE_FIXED
-                    | PD_PDO_SNK_FIXED_VOLTAGE_SET(PD_PDO_SRC_FIXED_VOLTAGE_GET(dpm_data->capabilities, i))
-                    | PD_PDO_SNK_FIXED_CURRENT_SET(PD_PDO_SRC_FIXED_CURRENT_GET(dpm_data->capabilities, i));
+                    | PD_PDO_SNK_FIXED_VOLTAGE_SET(PD_PDO_SRC_FIXED_VOLTAGE_GET(dpm_data->capabilities->obj[i]))
+                    | PD_PDO_SNK_FIXED_CURRENT_SET(PD_PDO_SRC_FIXED_CURRENT_GET(dpm_data->capabilities->obj[i]));
             }
 
             /* If we have three PDOs at this point, make sure the last two are