Make requests from PPS APDOs

PPS APDOs are second priority, behind fixed supply PDOs.

lib/include/pd.h

 /* 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)
 
+/* PD Source Programmable Power Supply APDO */
+#define PD_APDO_SRC_PPS_MAX_VOLTAGE_SHIFT 17
+#define PD_APDO_SRC_PPS_MAX_VOLTAGE (0xFF << PD_APDO_SRC_PPS_MAX_VOLTAGE_SHIFT)
+#define PD_APDO_SRC_PPS_MIN_VOLTAGE_SHIFT 8
+#define PD_APDO_SRC_PPS_MIN_VOLTAGE (0xFF << PD_APDO_SRC_PPS_MIN_VOLTAGE_SHIFT)
+#define PD_APDO_SRC_PPS_CURRENT_SHIFT 0
+#define PD_APDO_SRC_PPS_CURRENT (0x7F << PD_APDO_SRC_PPS_CURRENT_SHIFT)
+
+/* PD Source Programmable Power Supply APDO voltages */
+#define PD_APDO_SRC_PPS_MAX_VOLTAGE_GET(msg, i) (((msg)->obj[(i)] & PD_APDO_SRC_PPS_MAX_VOLTAGE) >> PD_APDO_SRC_PPS_MAX_VOLTAGE_SHIFT)
+#define PD_APDO_SRC_PPS_MIN_VOLTAGE_GET(msg, i) (((msg)->obj[(i)] & PD_APDO_SRC_PPS_MIN_VOLTAGE) >> PD_APDO_SRC_PPS_MIN_VOLTAGE_SHIFT)
+
+/* PD Source Programmable Power Supply APDO current */
+#define PD_APDO_SRC_PPS_CURRENT_GET(msg, i) (((msg)->obj[(i)] & PD_APDO_SRC_PPS_CURRENT) >> PD_APDO_SRC_PPS_CURRENT_SHIFT)
+
 /* TODO: other types of source PDO */
 
 /* PD Sink Fixed PDO */
 
 /* TODO: Battery RDOs */
 
+/* Programmable RDO */
+#define PD_RDO_PROG_VOLTAGE_SHIFT 9
+#define PD_RDO_PROG_VOLTAGE (0x7FF << PD_RDO_PROG_VOLTAGE_SHIFT)
+#define PD_RDO_PROG_CURRENT_SHIFT 0
+#define PD_RDO_PROG_CURRENT (0x7F << PD_RDO_PROG_CURRENT_SHIFT)
+
+#define PD_RDO_PROG_VOLTAGE_SET(i) (((i) << PD_RDO_PROG_VOLTAGE_SHIFT) & PD_RDO_PROG_VOLTAGE)
+#define PD_RDO_PROG_CURRENT_SET(i) (((i) << PD_RDO_PROG_CURRENT_SHIFT) & PD_RDO_PROG_CURRENT)
+
 
 /*
  * Time values
  * V: volt
  * CV: centivolt
  * MV: millivolt
+ * PRV: Programmable RDO voltage unit (20 mV)
  * PDV: Power Delivery voltage unit (50 mV)
+ * PAV: PPS APDO voltage unit (100 mV)
  * A: ampere
  * CA: centiampere
  * MA: milliampere
  * PDI: Power Delivery current unit (10 mA)
+ * PAI: PPS APDO current unit (50 mA)
  */
+#define PD_MV2PRV(mv) ((mv) / 20)
 #define PD_MV2PDV(mv) ((mv) / 50)
+#define PD_MV2PAV(mv) ((mv) / 100)
+#define PD_PRV2MV(prv) ((prv) * 20)
 #define PD_PDV2MV(pdv) ((pdv) * 50)
+#define PD_PAV2MV(pav) ((pav) * 100)
 #define PD_MA2PDI(ma) ((ma) / 10)
+#define PD_MA2PAI(ma) ((ma) / 50)
+#define PD_CA2PAI(ca) ((ca) / 5)
 #define PD_PDI2MA(pdi) ((pdi) * 10)
+#define PD_PAI2MA(pai) ((pai) * 50)
+#define PD_PAI2CA(pai) ((pai) * 5)
 
 /* Get portions of a voltage in more normal units */
 #define PD_MV_V(mv) ((mv) / 1000)

src/device_policy_manager.c

     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
-             * 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) == PD_MV2PDV(scfg->v)
+            /* 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) {
                 /* 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_MV2PDV(scfg->v));
 
+                dpm_data->_capability_match = true;
+                return true;
+            }
+            /* 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_SRC_PPS_MAX_VOLTAGE_GET(capabilities, i) >= PD_MV2PAV(scfg->v)
+                    && PD_APDO_SRC_PPS_MIN_VOLTAGE_GET(capabilities, i) <= PD_MV2PAV(scfg->v)
+                    && PD_APDO_SRC_PPS_CURRENT_GET(capabilities, 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);
+
+                /* Build a request */
+                request->obj[0] = PD_RDO_PROG_CURRENT_SET(PD_CA2PAI(scfg->i))
+                    | PD_RDO_PROG_VOLTAGE_SET(PD_MV2PRV(scfg->v))
+                    | PD_RDO_NO_USB_SUSPEND | PD_RDO_OBJPOS_SET(i + 1);
+                if (dpm_data->usb_comms) {
+                    request->obj[0] |= PD_RDO_USB_COMMS;
+                }
+
+                /* Update requested voltage */
+                dpm_data->_requested_voltage = PD_PRV2MV(PD_MV2PRV(scfg->v));
+
                 dpm_data->_capability_match = true;
                 return true;
             }