UsbPdDefs.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <stdint.h>
 
namespace usbpd
{
 
inline uint16_t le16(const uint8_t *p)
{
    return (uint16_t)p[0] | ((uint16_t)p[1] << 8);
}
 
inline uint32_t le32(const uint8_t *p)
{
    return (uint32_t)p[0] |
           ((uint32_t)p[1] << 8) |
           ((uint32_t)p[2] << 16) |
           ((uint32_t)p[3] << 24);
}
 
inline void wr_le16(uint8_t *p, uint16_t v)
{
    p[0] = (uint8_t)(v & 0xFF);
    p[1] = (uint8_t)((v >> 8) & 0xFF);
}
 
inline void wr_le32(uint8_t *p, uint32_t v)
{
    p[0] = (uint8_t)(v & 0xFF);
    p[1] = (uint8_t)((v >> 8) & 0xFF);
    p[2] = (uint8_t)((v >> 16) & 0xFF);
    p[3] = (uint8_t)((v >> 24) & 0xFF);
}
 
struct Header {
    uint16_t raw = 0;
 
    Header() = default;
 
    explicit Header(uint16_t v) : raw(v) {}
 
    uint8_t  msgType()   const
    {
        return (uint8_t)(raw & 0x1F);
    }
 
    bool dataRoleDfp() const
    {
        return ((raw >> 5) & 0x1) != 0;
    }
 
    uint8_t  specRev()   const
    {
        return (uint8_t)((raw >> 6) & 0x3);
    }
 
    bool powerRoleSource() const
    {
        return ((raw >> 8) & 0x1) != 0;
    }
 
    uint8_t msgId() const
    {
        return (uint8_t)((raw >> 9) & 0x7);
    }
 
    uint8_t objCount()  const
    {
        return (uint8_t)((raw >> 12) & 0x7);
    }
 
    bool extended()  const
    {
        return ((raw >> 15) & 0x1) != 0;
    }
 
    void setMsgType(uint8_t v)
    {
        raw = (uint16_t)((raw & ~0x001F) | (v & 0x1F));
    }
 
    void setDataRoleDfp(bool dfp)
    {
        raw = (uint16_t)((raw & ~(1u << 5)) | ((uint16_t)dfp << 5));
    }
 
    void setSpecRev(uint8_t r)
    {
        raw = (uint16_t)((raw & ~(3u << 6)) | ((uint16_t)(r & 0x3) << 6));
    }
 
    void setPowerRoleSource(bool src)
    {
        raw = (uint16_t)((raw & ~(1u << 8)) | ((uint16_t)src << 8));
    }
 
    void setMsgId(uint8_t id)
    {
        raw = (uint16_t)((raw & ~(7u << 9)) | ((uint16_t)(id & 0x7) << 9));
    }
 
    void setObjCount(uint8_t n)
    {
        raw = (uint16_t)((raw & ~(7u << 12)) | ((uint16_t)(n & 0x7) << 12));
    }
 
    void setExtended(bool ex)
    {
        raw = (uint16_t)((raw & ~(1u << 15)) | ((uint16_t)ex << 15));
    }
};
 
enum class SpecRev : uint8_t {
    Rev10 = 0, 
    Rev20 = 1, 
    Rev30 = 2, 
};
 
enum class ControlMsg : uint8_t {
    GoodCRC      = 0x01, 
    GotoMin      = 0x02, 
    Accept       = 0x03, 
    Reject       = 0x04, 
    Ping         = 0x05, 
    PS_RDY       = 0x06, 
    GetSourceCap = 0x07, 
    GetSinkCap   = 0x08, 
    DR_Swap      = 0x09, 
    PR_Swap      = 0x0A, 
    VCONN_Swap   = 0x0B, 
    Wait         = 0x0C, 
    SoftReset    = 0x0D, 
};
 
enum class DataMsg : uint8_t {
    SourceCapabilities = 0x01, 
    Request            = 0x02, 
    BIST               = 0x03, 
    SinkCapabilities   = 0x04, 
    VendorDefined      = 0x0F, 
};
 
inline uint16_t buildControlHeader(
    ControlMsg type,
    uint8_t msgId,
    bool powerRoleSource,
    bool dataRoleDfp,
    SpecRev specRev
)
{
    Header h{};
    h.setExtended(false);
    h.setObjCount(0);
    h.setMsgId(msgId);
    h.setPowerRoleSource(powerRoleSource);
    h.setSpecRev((uint8_t)specRev);
    h.setDataRoleDfp(dataRoleDfp);
    h.setMsgType((uint8_t)type);
    return h.raw;
}
 
inline uint16_t buildDataHeader(
    DataMsg type,
    uint8_t objCount,
    uint8_t msgId,
    bool powerRoleSource,
    bool dataRoleDfp,
    SpecRev specRev
)
{
    Header h{};
    h.setExtended(false);
    h.setObjCount(objCount);
    h.setMsgId(msgId);
    h.setPowerRoleSource(powerRoleSource);
    h.setSpecRev((uint8_t)specRev);
    h.setDataRoleDfp(dataRoleDfp);
    h.setMsgType((uint8_t)type);
    return h.raw;
}
 
enum class PdoType : uint8_t {
    Fixed     = 0b00, 
    Battery   = 0b01, 
    Variable  = 0b10, 
    Augmented = 0b11, 
};
 
struct FixedSourcePdo {
    uint16_t mv = 0; 
    uint16_t ma = 0; 
    bool usbCommCapable = false; 
    bool dualRolePower = false;  
};
 
inline PdoType pdoType(uint32_t pdo)
{
    return (PdoType)((pdo >> 30) & 0x03);
}
 
inline bool parseFixedSourcePdo(uint32_t pdo, FixedSourcePdo &out)
{
    if (pdoType(pdo) != PdoType::Fixed) return false;
 
    uint16_t v50 = (uint16_t)((pdo >> 10) & 0x03FF);
    uint16_t i10 = (uint16_t)(pdo & 0x03FF);
 
    out.mv = (uint16_t)(v50 * 50);
    out.ma = (uint16_t)(i10 * 10);
 
    out.usbCommCapable = ((pdo >> 26) & 0x1) != 0;
    out.dualRolePower  = ((pdo >> 29) & 0x1) != 0;
    return true;
}
 
inline uint32_t buildRdoFixedCurrent(
    uint8_t objectPos1based,
    uint16_t opMa,
    uint16_t maxMa,
    bool capMismatch = false,
    bool usbCommCapable = true,
    bool noUsbSuspend = true
)
{
    if (objectPos1based < 1) objectPos1based = 1;
    if (objectPos1based > 7) objectPos1based = 7;
 
    uint16_t opI10  = (uint16_t)(opMa / 10);
    uint16_t maxI10 = (uint16_t)(maxMa / 10);
    if (opI10 > 0x3FF) opI10 = 0x3FF;
    if (maxI10 > 0x3FF) maxI10 = 0x3FF;
 
    uint32_t rdo = 0;
    rdo |= ((uint32_t)(objectPos1based & 0x0F) << 28);
    rdo |= ((uint32_t)(capMismatch ? 1u : 0u) << 26);
    rdo |= ((uint32_t)(usbCommCapable ? 1u : 0u) << 25);
    rdo |= ((uint32_t)(noUsbSuspend ? 1u : 0u) << 24);
    rdo |= ((uint32_t)(opI10 & 0x3FF) << 10);
    rdo |= ((uint32_t)(maxI10 & 0x3FF) << 0);
    return rdo;
}
 
} // namespace usbpd