pf1550_voltage_tables.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
 
#include "pf1550_registers.hpp"
 
namespace pf1550 {
 
constexpr uint16_t SwCodeToMillivolts(uint8_t code) noexcept {
  constexpr uint16_t kTable[7] = {1100, 1200, 1350, 1500, 1800, 2500, 3000};
  const uint8_t c = static_cast<uint8_t>(code & 0x3FU);
  return c < 7U ? kTable[c] : 3300U;
}
 
constexpr uint16_t SwDvsCodeToMillivolts(uint8_t code) noexcept {
  return static_cast<uint16_t>(600U + (static_cast<uint32_t>(code & 0x3FU) * 25U + 1U) / 2U);
}
 
constexpr uint8_t SwDvsMillivoltsToCode(uint16_t mv) noexcept {
  for (uint8_t code = 0; code < 64U; ++code) {
    if (SwDvsCodeToMillivolts(code) == mv) {
      return code;
    }
  }
  return 0xFFU;
}
 
constexpr uint16_t Sw3CodeToMillivolts(uint8_t code) noexcept {
  return static_cast<uint16_t>(1800U + 100U * (code & 0x0FU));
}
 
constexpr uint8_t SwMillivoltsToCode(uint16_t mv) noexcept {
  switch (mv) {
    case 1100: return 0x00;
    case 1200: return 0x01;
    case 1350: return 0x02;
    case 1500: return 0x03;
    case 1800: return 0x04;
    case 2500: return 0x05;
    case 3000: return 0x06;
    case 3300: return 0x07;
    default:   return 0xFFU;
  }
}
 
constexpr uint16_t LdoCodeToMillivolts(uint8_t code, bool is_ldo2) noexcept {
  const uint8_t c = static_cast<uint8_t>(code & 0x1FU);
  if (is_ldo2) {
    if (c <= 0x0FU) {
      return static_cast<uint16_t>(1800U + 100U * c);
    }
    return 0U;
  }
  if (c <= 0x0FU) {
    return static_cast<uint16_t>(750U + 50U * c);
  }
  return static_cast<uint16_t>(1800U + 100U * (c - 0x10U));
}
 
constexpr uint16_t VbusLimitRegToMilliamps(uint8_t reg_value) noexcept {
  const uint8_t code = static_cast<uint8_t>((reg_value >> 3U) & 0x1FU);
  // First 9 entries: 10, 15, 20, 25, 30, 35, 40, 45, 50 mA (5 mA step from 10).
  if (code <= 0x08U) {
    return static_cast<uint16_t>(10U + 5U * code);
  }
  // 0x09..0x0F: 100, 150, 200, 300, 400, 500, 600 mA.
  switch (code) {
    case 0x09: return 100;
    case 0x0A: return 150;
    case 0x0B: return 200;
    case 0x0C: return 300;
    case 0x0D: return 400;
    case 0x0E: return 500;
    case 0x0F: return 600;
    case 0x10: return 700;
    case 0x11: return 800;
    case 0x12: return 900;
    case 0x13: return 1000;
    case 0x14: return 1500;  // Portenta default
    default: return 0;       // codes 21..31 are reserved (Table 58)
  }
}
 
constexpr uint8_t VbusLimitMilliampsToReg(uint16_t mA) noexcept {
  uint8_t code = 0xFFU;
  switch (mA) {
    case 10:   code = 0x00; break;
    case 100:  code = 0x09; break;
    case 500:  code = 0x0E; break;
    case 1000: code = 0x13; break;
    case 1500: code = 0x14; break;  // Portenta default
  }
  return (code == 0xFFU) ? 0xFFU : static_cast<uint8_t>(code << 3U);
}
 
constexpr uint16_t SwCurrentLimitCodeToMilliamps(uint8_t code) noexcept {
  switch (code & 0x03U) {
    case 0: return 1000;
    case 1: return 1200;
    case 2: return 1500;
    case 3: return 2000;
  }
  return 0;
}
 
constexpr PmicState DecodeStateInfo(uint8_t reg) noexcept {
  switch (reg & 0x3FU) {
    case 0b000000: return PmicState::Wait;
    case 0b001100: return PmicState::Run;
    case 0b001101: return PmicState::Standby;
    case 0b001110: return PmicState::Sleep;
    case 0b101011: return PmicState::RegsDisable;
    default:       return PmicState::Unknown;
  }
}
 
constexpr ChargerState DecodeChargerSense(uint8_t reg) noexcept {
  switch (reg & 0x0FU) {
    case 0:  return ChargerState::PreCharge;
    case 1:  return ChargerState::FastCC;
    case 2:  return ChargerState::FastCV;
    case 3:  return ChargerState::EndOfCharge;
    case 4:  return ChargerState::Done;
    case 6:  return ChargerState::TimerFault;
    case 7:  return ChargerState::ThermSuspend;
    case 8:  return ChargerState::Off;
    case 9:  return ChargerState::BatteryOv;
    case 10: return ChargerState::TempShutdown;
    case 12: return ChargerState::LinearOnly;
    default: return ChargerState::Unknown;
  }
}
 
static_assert(SwCodeToMillivolts(0x06) == 3000, "SW code 0x06 → 3.00 V (Portenta SW1 RUN)");
static_assert(SwCodeToMillivolts(static_cast<uint8_t>(SwVoltageCode::V3_3)) == 3300,
              "SwVoltageCode::V3_3 must decode to 3.30 V");
static_assert(Sw3CodeToMillivolts(static_cast<uint8_t>(SwVoltageCode::V3_1)) == 3100,
              "SW3 code 0x0D → 3.10 V (Table 37)");
static_assert(SwCodeToMillivolts(0x0D) == 3300, "SW1/SW2 DVS-disabled: every code ≥ 7 is 3.30 V");
static_assert(SwDvsCodeToMillivolts(0x00) == 600 && SwDvsCodeToMillivolts(0x3F) == 1388 &&
                  SwDvsCodeToMillivolts(0x20) == 1000,
              "SW1/SW2 DVS-enabled: 0.6 V + 12.5 mV steps");
static_assert(SwDvsMillivoltsToCode(1100) == 40 && SwDvsMillivoltsToCode(1388) == 0x3F &&
                  SwDvsMillivoltsToCode(1006) == 0xFFU,
              "DVS encode is the inverse of SwDvsCodeToMillivolts");
static_assert(Sw3CodeToMillivolts(0x0F) == 3300 && Sw3CodeToMillivolts(0x00) == 1800, "SW3 Table 37");
static_assert(SwMillivoltsToCode(3300) == 0x07, "3300 mV round-trip → 0x07");
static_assert(LdoCodeToMillivolts(static_cast<uint8_t>(LdoVoltageCode::V1_0), /*is_ldo2=*/false) == 1000,
              "LDO1 code 0x05 → 1.0 V");
static_assert(LdoCodeToMillivolts(static_cast<uint8_t>(LdoVoltageCode::V1_8), /*is_ldo2=*/true) == 1800,
              "LDO2 code 0x00 → 1.8 V");
static_assert(LdoCodeToMillivolts(static_cast<uint8_t>(LdoVoltageCode::V1_2), /*is_ldo2=*/false) == 1200,
              "LDO3 code 0x09 → 1.2 V");
static_assert(VbusLimitRegToMilliamps(0xA0) == 1500,
              "Portenta sets 0xA0 (code 0x14) → 1500 mA per VBUS_IN_LIM_CNFG lookup");
static_assert(VbusLimitMilliampsToReg(1500) == 0xA0,
              "VbusLimitMilliampsToReg(1500) must round-trip to 0xA0");
 
} // namespace pf1550