Use millivolts internally instead of PDV

This commit breaks old configuration by interpreting stored voltages as
millivolts, rather than 50 mV.  This will allow the finer voltage
increments used by programmable power supplies to be specified.

lib/include/pd.h

 #define PD_MA2PDI(ma) ((ma) / 10)
 #define PD_PDI2MA(pdi) ((pdi) * 10)
 
-/* Get portions of a PD voltage in more normal units */
+/* Get portions of a voltage in more normal units */
+#define PD_MV_V(mv) ((mv) / 1000)
+#define PD_MV_MV(mv) ((mv) % 1000)
+
 #define PD_PDV_V(pdv) ((pdv) / 20)
 #define PD_PDV_CV(pdv) (5 * ((pdv) % 20))
 

src/config.c

     chprintf(chp, "\r\n");
 
     /* Print voltage */
-    chprintf(chp, "v: %d.%02d V\r\n", PD_PDV_V(cfg->v), PD_PDV_CV(cfg->v));
+    chprintf(chp, "v: %d.%03d V\r\n", PD_MV_V(cfg->v), PD_MV_MV(cfg->v));
     /* Print current-deriving setting */
     switch (cfg->flags & PDBS_CONFIG_FLAGS_CURRENT_DEFN) {
         case PDBS_CONFIG_FLAGS_CURRENT_DEFN_I:
     }
     /* If either end of the range is non-zero, print the range */
     if (cfg->vmin != 0 || cfg->vmax != 0) {
-        chprintf(chp, "vmin: %d.%02d V\r\n", PD_PDV_V(cfg->vmin),
-                 PD_PDV_CV(cfg->vmin));
-        chprintf(chp, "vmax: %d.%02d V\r\n", PD_PDV_V(cfg->vmax),
-                 PD_PDV_CV(cfg->vmax));
+        chprintf(chp, "vmin: %d.%03d V\r\n", PD_MV_V(cfg->vmin),
+                 PD_MV_MV(cfg->vmin));
+        chprintf(chp, "vmax: %d.%03d V\r\n", PD_MV_V(cfg->vmax),
+                 PD_MV_MV(cfg->vmax));
     }
 }
 

src/config.h

     uint16_t status;
     /* Flags halfword for miscellaneous small fields. */
     uint16_t flags;
-    /* Preferred voltage. */
+    /* Preferred voltage, in millivolts. */
     uint16_t v;
     /* Union for specifying how much current to request. */
     union {
-        /* Required current. */
+        /* Required current, in centiamperes. */
         uint16_t i;
-        /* Required power. */
+        /* Required power, in centiwatts. */
         uint16_t p;
-        /* Value of resistive load. */
+        /* Value of resistive load, in centiohms. */
         uint16_t r;
     };
-    /* Lower end of voltage range. */
+    /* Lower end of voltage range, in millivolts. */
     uint16_t vmin;
-    /* Upper end of voltage range. */
+    /* Upper end of voltage range, in millivolts. */
     uint16_t vmax;
     /* Extra bytes reserved for future use. */
     uint16_t _reserved[2];

src/device_policy_manager.c

             }
             /* 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) == scfg->v
+            if (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 = scfg->v;
+                dpm_data->_requested_voltage = PD_PDV2MV(PD_MV2PDV(scfg->v));
 
                 dpm_data->_capability_match = true;
                 return true;
     }
 
     /* Update requested voltage */
-    dpm_data->_requested_voltage = PD_MV2PDV(5000);
+    dpm_data->_requested_voltage = 5000;
 
     /* At this point, we have a capability match iff the output is disabled */
     dpm_data->_capability_match = !dpm_data->output_enabled;
 
     /* If we have no configuration or want something other than 5 V, add a PDO
      * for vSafe5V */
-    if (scfg == NULL || scfg->v != PD_MV2PDV(5000)) {
+    if (scfg == NULL || PD_MV2PDV(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 (scfg != NULL) {
         cap->obj[numobj++] = PD_PDO_TYPE_FIXED
-            | PD_PDO_SNK_FIXED_VOLTAGE_SET(scfg->v)
+            | PD_PDO_SNK_FIXED_VOLTAGE_SET(PD_MV2PDV(scfg->v))
             | PD_PDO_SNK_FIXED_CURRENT_SET(scfg->i);
         /* If we want more than 5 V, set the Higher Capability flag */
-        if (scfg->v != PD_MV2PDV(5000)) {
+        if (PD_MV2PDV(scfg->v) != PD_MV2PDV(5000)) {
             cap->obj[0] |= PD_PDO_SNK_FIXED_HIGHER_CAP;
         }
     }
     struct pdbs_dpm_data *dpm_data = cfg->dpm_data;
 
     /* We don't control the voltage anymore; it will always be 5 V. */
-    dpm_data->_requested_voltage = PD_MV2PDV(5000);
+    dpm_data->_requested_voltage = 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)) {
+    if (scfg == NULL || PD_MV2PDV(scfg->v) != PD_MV2PDV(5000)) {
         dpm_data->_capability_match = false;
         return false;
     }
     struct pdbs_dpm_data *dpm_data = cfg->dpm_data;
 
     /* Pretend we requested 5 V */
-    dpm_data->_requested_voltage = PD_MV2PDV(5000);
+    dpm_data->_requested_voltage = 5000;
     /* Turn the output off */
     dpm_output_set(cfg->dpm_data, false);
 }

src/device_policy_manager.h

     bool _unconstrained_power;
     /* Whether our capabilities matched or not */
     bool _capability_match;
-    /* The last explicitly or implicitly negotiated voltage in PDV */
+    /* The last explicitly or implicitly negotiated voltage, in millivolts */
     int _present_voltage;
-    /* The requested voltage */
+    /* The requested voltage, in millivolts */
     int _requested_voltage;
 };
 

src/main.c

     true,
     true,
     false,
-    ._present_voltage = PD_MV2PDV(5000)
+    ._present_voltage = 5000
 };
 
 /*

src/shell.c

     char *endptr;
     long i = strtol(argv[0], &endptr, 0);
     if (i >= PD_MV_MIN && i <= PD_MV_MAX && endptr > argv[0]) {
-        /* Convert mV to the unit used by USB PD */
-        tmpcfg.v = PD_MV2PDV(i);
+        tmpcfg.v = i;
     } else {
         chprintf(chp, "Invalid voltage\r\n");
         return;