usbc_tcpc.h

Go to the documentation of this file.

/*
 * Copyright 2022 The Chromium OS Authors
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_USB_C_USBC_TCPC_H_
#define ZEPHYR_INCLUDE_DRIVERS_USB_C_USBC_TCPC_H_

 
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <errno.h>
 
#include "usbc_tc.h"
#include "usbc_pd.h"
 
#ifdef __cplusplus
extern "C" {
#endif

enum tcpc_alert {
        TCPC_ALERT_CC_STATUS,
        TCPC_ALERT_POWER_STATUS,
        TCPC_ALERT_MSG_STATUS,
        TCPC_ALERT_HARD_RESET_RECEIVED,
        TCPC_ALERT_TRANSMIT_MSG_FAILED,
        TCPC_ALERT_TRANSMIT_MSG_DISCARDED,
        TCPC_ALERT_TRANSMIT_MSG_SUCCESS,
        TCPC_ALERT_VBUS_ALARM_HI,
        TCPC_ALERT_VBUS_ALARM_LO,
        TCPC_ALERT_FAULT_STATUS,
        TCPC_ALERT_RX_BUFFER_OVERFLOW,
        TCPC_ALERT_VBUS_SNK_DISCONNECT,
        TCPC_ALERT_BEGINNING_MSG_STATUS,
        TCPC_ALERT_EXTENDED_STATUS,
        TCPC_ALERT_EXTENDED,
        TCPC_ALERT_VENDOR_DEFINED
};

enum tcpc_status_reg {
        TCPC_ALERT_STATUS,
        TCPC_CC_STATUS,
        TCPC_POWER_STATUS,
        TCPC_FAULT_STATUS,
        TCPC_EXTENDED_STATUS,
        TCPC_EXTENDED_ALERT_STATUS,
        TCPC_VENDOR_DEFINED_STATUS
};

struct tcpc_chip_info {
        uint16_t vendor_id;
        uint16_t product_id;
        uint16_t device_id;
        uint64_t fw_version_number;

        union {
                uint8_t min_req_fw_version_string[8];
                uint64_t min_req_fw_version_number;
        };
};

typedef int (*tcpc_vconn_control_cb_t)(const struct device *tcpc_dev, const struct device *usbc_dev,
                                       enum tc_cc_polarity pol, bool enable);

typedef int (*tcpc_vconn_discharge_cb_t)(const struct device *tcpc_dev,
                                         const struct device *usbc_dev, enum tc_cc_polarity pol,
                                         bool enable);

typedef void (*tcpc_alert_handler_cb_t)(const struct device *dev, void *data,
                                        enum tcpc_alert alert);


typedef int (*tcpc_api_init_t)(const struct device *dev);

typedef int (*tcpc_api_get_cc_t)(const struct device *dev, enum tc_cc_voltage_state *cc1,
                                 enum tc_cc_voltage_state *cc2);

typedef int (*tcpc_api_select_rp_value_t)(const struct device *dev, enum tc_rp_value rp);

typedef int (*tcpc_api_get_rp_value_t)(const struct device *dev, enum tc_rp_value *rp);

typedef int (*tcpc_api_set_cc_t)(const struct device *dev, enum tc_cc_pull pull);

typedef void (*tcpc_api_set_vconn_discharge_cb_t)(const struct device *dev,
                                                  tcpc_vconn_discharge_cb_t cb,
                                                  const struct device *usbc_dev);

typedef void (*tcpc_api_set_vconn_cb_t)(const struct device *dev, tcpc_vconn_control_cb_t vconn_cb,
                                        const struct device *usbc_dev);

typedef int (*tcpc_api_vconn_discharge_t)(const struct device *dev, bool enable);

typedef int (*tcpc_api_set_vconn_t)(const struct device *dev, bool enable);

typedef int (*tcpc_api_set_roles_t)(const struct device *dev, enum tc_power_role power_role,
                                    enum tc_data_role data_role);

typedef int (*tcpc_api_get_rx_pending_msg_t)(const struct device *dev, struct pd_msg *msg);

typedef int (*tcpc_api_set_rx_enable_t)(const struct device *dev, bool enable);

typedef int (*tcpc_api_set_cc_polarity_t)(const struct device *dev, enum tc_cc_polarity polarity);

typedef int (*tcpc_api_transmit_data_t)(const struct device *dev, struct pd_msg *msg);

typedef int (*tcpc_api_dump_std_reg_t)(const struct device *dev);

typedef int (*tcpc_api_get_status_register_t)(const struct device *dev, enum tcpc_status_reg reg,
                                              uint32_t *status);

typedef int (*tcpc_api_clear_status_register_t)(const struct device *dev, enum tcpc_status_reg reg,
                                                uint32_t mask);

typedef int (*tcpc_api_mask_status_register_t)(const struct device *dev, enum tcpc_status_reg reg,
                                               uint32_t mask);

typedef int (*tcpc_api_set_debug_accessory_t)(const struct device *dev, bool enable);

typedef int (*tcpc_api_set_debug_detach_t)(const struct device *dev);

typedef int (*tcpc_api_set_drp_toggle_t)(const struct device *dev, bool enable);

typedef int (*tcpc_api_get_snk_ctrl_t)(const struct device *dev);

typedef int (*tcpc_api_set_snk_ctrl_t)(const struct device *dev, bool enable);

typedef int (*tcpc_api_get_src_ctrl_t)(const struct device *dev);

typedef int (*tcpc_api_set_src_ctrl_t)(const struct device *dev, bool enable);

typedef int (*tcpc_api_get_chip_info_t)(const struct device *dev, struct tcpc_chip_info *chip_info);

typedef int (*tcpc_api_set_low_power_mode_t)(const struct device *dev, bool enable);

typedef int (*tcpc_api_sop_prime_enable_t)(const struct device *dev, bool enable);

typedef int (*tcpc_api_set_bist_test_mode_t)(const struct device *dev, bool enable);

typedef int (*tcpc_api_set_alert_handler_cb_t)(const struct device *dev,
                                               tcpc_alert_handler_cb_t handler, void *data);

__subsystem struct tcpc_driver_api {
        tcpc_api_init_t init;
        tcpc_api_get_cc_t get_cc;
        tcpc_api_select_rp_value_t select_rp_value;
        tcpc_api_get_rp_value_t get_rp_value;
        tcpc_api_set_cc_t set_cc;
        tcpc_api_set_vconn_discharge_cb_t set_vconn_discharge_cb;
        tcpc_api_set_vconn_cb_t set_vconn_cb;
        tcpc_api_vconn_discharge_t vconn_discharge;
        tcpc_api_set_vconn_t set_vconn;
        tcpc_api_set_roles_t set_roles;
        tcpc_api_get_rx_pending_msg_t get_rx_pending_msg;
        tcpc_api_set_rx_enable_t set_rx_enable;
        tcpc_api_set_cc_polarity_t set_cc_polarity;
        tcpc_api_transmit_data_t transmit_data;
        tcpc_api_dump_std_reg_t dump_std_reg;
        tcpc_api_get_status_register_t get_status_register;
        tcpc_api_clear_status_register_t clear_status_register;
        tcpc_api_mask_status_register_t mask_status_register;
        tcpc_api_set_debug_accessory_t set_debug_accessory;
        tcpc_api_set_debug_detach_t set_debug_detach;
        tcpc_api_set_drp_toggle_t set_drp_toggle;
        tcpc_api_get_snk_ctrl_t get_snk_ctrl;
        tcpc_api_set_snk_ctrl_t set_snk_ctrl;
        tcpc_api_get_src_ctrl_t get_src_ctrl;
        tcpc_api_set_src_ctrl_t set_src_ctrl;
        tcpc_api_get_chip_info_t get_chip_info;
        tcpc_api_set_low_power_mode_t set_low_power_mode;
        tcpc_api_sop_prime_enable_t sop_prime_enable;
        tcpc_api_set_bist_test_mode_t set_bist_test_mode;
        tcpc_api_set_alert_handler_cb_t set_alert_handler_cb;
};


static inline int tcpc_is_cc_rp(enum tc_cc_voltage_state cc)
{
        return (cc == TC_CC_VOLT_RP_DEF) || (cc == TC_CC_VOLT_RP_1A5) || (cc == TC_CC_VOLT_RP_3A0);
}

static inline int tcpc_is_cc_open(enum tc_cc_voltage_state cc1, enum tc_cc_voltage_state cc2)
{
        return (cc1 < TC_CC_VOLT_RD) && (cc2 < TC_CC_VOLT_RD);
}

static inline int tcpc_is_cc_snk_dbg_acc(enum tc_cc_voltage_state cc1, enum tc_cc_voltage_state cc2)
{
        return cc1 == TC_CC_VOLT_RD && cc2 == TC_CC_VOLT_RD;
}

static inline int tcpc_is_cc_src_dbg_acc(enum tc_cc_voltage_state cc1, enum tc_cc_voltage_state cc2)
{
        return tcpc_is_cc_rp(cc1) && tcpc_is_cc_rp(cc2);
}

static inline int tcpc_is_cc_audio_acc(enum tc_cc_voltage_state cc1, enum tc_cc_voltage_state cc2)
{
        return cc1 == TC_CC_VOLT_RA && cc2 == TC_CC_VOLT_RA;
}

static inline int tcpc_is_cc_at_least_one_rd(enum tc_cc_voltage_state cc1,
                                             enum tc_cc_voltage_state cc2)
{
        return cc1 == TC_CC_VOLT_RD || cc2 == TC_CC_VOLT_RD;
}

static inline int tcpc_is_cc_only_one_rd(enum tc_cc_voltage_state cc1, enum tc_cc_voltage_state cc2)
{
        return tcpc_is_cc_at_least_one_rd(cc1, cc2) && cc1 != cc2;
}

static inline int tcpc_init(const struct device *dev)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        __ASSERT(api->init != NULL, "Callback pointer should not be NULL");
 
        return api->init(dev);
}

static inline int tcpc_get_cc(const struct device *dev, enum tc_cc_voltage_state *cc1,
                              enum tc_cc_voltage_state *cc2)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->get_cc == NULL) {
                return -ENOSYS;
        }
 
        return api->get_cc(dev, cc1, cc2);
}

static inline int tcpc_select_rp_value(const struct device *dev, enum tc_rp_value rp)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->select_rp_value == NULL) {
                return -ENOSYS;
        }
 
        return api->select_rp_value(dev, rp);
}

static inline int tcpc_get_rp_value(const struct device *dev, enum tc_rp_value *rp)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->get_rp_value == NULL) {
                return -ENOSYS;
        }
 
        return api->get_rp_value(dev, rp);
}

static inline int tcpc_set_cc(const struct device *dev, enum tc_cc_pull pull)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        __ASSERT(api->set_cc != NULL, "Callback pointer should not be NULL");
 
        return api->set_cc(dev, pull);
}

static inline void tcpc_set_vconn_cb(const struct device *dev, tcpc_vconn_control_cb_t vconn_cb,
                                     const struct device *usbc_dev)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        __ASSERT(api->set_vconn_cb != NULL, "Callback pointer should not be NULL");
 
        api->set_vconn_cb(dev, vconn_cb, usbc_dev);
}

static inline void tcpc_set_vconn_discharge_cb(const struct device *dev,
                                               tcpc_vconn_discharge_cb_t cb,
                                               const struct device *usbc_dev)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        __ASSERT(api->set_vconn_discharge_cb != NULL, "Callback pointer should not be NULL");
 
        api->set_vconn_discharge_cb(dev, cb, usbc_dev);
}

static inline int tcpc_vconn_discharge(const struct device *dev, bool enable)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->vconn_discharge == NULL) {
                return -ENOSYS;
        }
 
        return api->vconn_discharge(dev, enable);
}

static inline int tcpc_set_vconn(const struct device *dev, bool enable)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->set_vconn == NULL) {
                return -ENOSYS;
        }
 
        return api->set_vconn(dev, enable);
}

static inline int tcpc_set_roles(const struct device *dev, enum tc_power_role power_role,
                                 enum tc_data_role data_role)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->set_roles == NULL) {
                return -ENOSYS;
        }
 
        return api->set_roles(dev, power_role, data_role);
}

static inline int tcpc_get_rx_pending_msg(const struct device *dev, struct pd_msg *buf)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        __ASSERT(api->get_rx_pending_msg != NULL, "Callback pointer should not be NULL");
 
        return api->get_rx_pending_msg(dev, buf);
}

static inline int tcpc_set_rx_enable(const struct device *dev, bool enable)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->set_rx_enable == NULL) {
                return -ENOSYS;
        }
 
        return api->set_rx_enable(dev, enable);
}

static inline int tcpc_set_cc_polarity(const struct device *dev, enum tc_cc_polarity polarity)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        __ASSERT(api->set_cc_polarity != NULL, "Callback pointer should not be NULL");
 
        return api->set_cc_polarity(dev, polarity);
}

static inline int tcpc_transmit_data(const struct device *dev, struct pd_msg *msg)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->transmit_data == NULL) {
                return -ENOSYS;
        }
 
        return api->transmit_data(dev, msg);
}

static inline int tcpc_dump_std_reg(const struct device *dev)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->dump_std_reg == NULL) {
                return -ENOSYS;
        }
 
        return api->dump_std_reg(dev);
}

static inline int tcpc_set_alert_handler_cb(const struct device *dev,
                                            tcpc_alert_handler_cb_t handler, void *data)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        __ASSERT(api->set_alert_handler_cb != NULL, "Callback pointer should not be NULL");
 
        return api->set_alert_handler_cb(dev, handler, data);
}

static inline int tcpc_get_status_register(const struct device *dev, enum tcpc_status_reg reg,
                                           uint32_t *status)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->get_status_register == NULL) {
                return -ENOSYS;
        }
 
        return api->get_status_register(dev, reg, status);
}

static inline int tcpc_clear_status_register(const struct device *dev, enum tcpc_status_reg reg,
                                             uint32_t mask)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->clear_status_register == NULL) {
                return -ENOSYS;
        }
 
        return api->clear_status_register(dev, reg, mask);
}

static inline int tcpc_mask_status_register(const struct device *dev, enum tcpc_status_reg reg,
                                            uint32_t mask)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->mask_status_register == NULL) {
                return -ENOSYS;
        }
 
        return api->mask_status_register(dev, reg, mask);
}

static inline int tcpc_set_debug_accessory(const struct device *dev, bool enable)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->set_debug_accessory == NULL) {
                return -ENOSYS;
        }
 
        return api->set_debug_accessory(dev, enable);
}

static inline int tcpc_set_debug_detach(const struct device *dev)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->set_debug_detach == NULL) {
                return -ENOSYS;
        }
 
        return api->set_debug_detach(dev);
}

static inline int tcpc_set_drp_toggle(const struct device *dev, bool enable)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->set_drp_toggle == NULL) {
                return -ENOSYS;
        }
 
        return api->set_drp_toggle(dev, enable);
}

static inline int tcpc_get_snk_ctrl(const struct device *dev)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->get_snk_ctrl == NULL) {
                return -ENOSYS;
        }
 
        return api->get_snk_ctrl(dev);
}

static inline int tcpc_set_snk_ctrl(const struct device *dev, bool enable)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->set_snk_ctrl == NULL) {
                return -ENOSYS;
        }
 
        return api->set_snk_ctrl(dev, enable);
}

static inline int tcpc_get_src_ctrl(const struct device *dev)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->get_src_ctrl == NULL) {
                return -ENOSYS;
        }
 
        return api->get_src_ctrl(dev);
}

static inline int tcpc_set_src_ctrl(const struct device *dev, bool enable)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->set_src_ctrl == NULL) {
                return -ENOSYS;
        }
 
        return api->set_src_ctrl(dev, enable);
}

static inline int tcpc_set_bist_test_mode(const struct device *dev, bool enable)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->set_bist_test_mode == NULL) {
                return -ENOSYS;
        }
 
        return api->set_bist_test_mode(dev, enable);
}

static inline int tcpc_get_chip_info(const struct device *dev, struct tcpc_chip_info *chip_info)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->get_chip_info == NULL) {
                return -ENOSYS;
        }
 
        return api->get_chip_info(dev, chip_info);
}

static inline int tcpc_set_low_power_mode(const struct device *dev, bool enable)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->set_low_power_mode == NULL) {
                return -ENOSYS;
        }
 
        return api->set_low_power_mode(dev, enable);
}

static inline int tcpc_sop_prime_enable(const struct device *dev, bool enable)
{
        const struct tcpc_driver_api *api = DEVICE_API_GET(tcpc, dev);
 
        if (api->sop_prime_enable == NULL) {
                return -ENOSYS;
        }
 
        return api->sop_prime_enable(dev, enable);
}

 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_USB_C_USBC_TCPC_H_ */