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_USBC_USBC_TCPC_H_
#define ZEPHYR_INCLUDE_DRIVERS_USBC_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_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 *dev,
                enum tc_cc_polarity pol, bool enable);
typedef int (*tcpc_vconn_discharge_cb_t)(const struct device *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);
 
__subsystem struct tcpc_driver_api {
        int (*init)(const struct device *dev);
        int (*get_cc)(const struct device *dev, enum tc_cc_voltage_state *cc1,
                        enum tc_cc_voltage_state *cc2);
        int (*select_rp_value)(const struct device *dev, enum tc_rp_value rp);
        int (*get_rp_value)(const struct device *dev, enum tc_rp_value *rp);
        int (*set_cc)(const struct device *dev, enum tc_cc_pull pull);
        void (*set_vconn_discharge_cb)(const struct device *dev, tcpc_vconn_discharge_cb_t cb);
        void (*set_vconn_cb)(const struct device *dev, tcpc_vconn_control_cb_t vconn_cb);
        int (*vconn_discharge)(const struct device *dev, bool enable);
        int (*set_vconn)(const struct device *dev, bool enable);
        int (*set_roles)(const struct device *dev, enum tc_power_role power_role,
                        enum tc_data_role data_role);
        int (*get_rx_pending_msg)(const struct device *dev, struct pd_msg *msg);
        int (*set_rx_enable)(const struct device *dev, bool enable);
        int (*set_cc_polarity)(const struct device *dev, enum tc_cc_polarity polarity);
        int (*transmit_data)(const struct device *dev, struct pd_msg *msg);
        int (*dump_std_reg)(const struct device *dev);
        void (*alert_handler_cb)(const struct device *dev, void *data, enum tcpc_alert alert);
        int (*get_status_register)(const struct device *dev, enum tcpc_status_reg reg,
                        int32_t *status);
        int (*clear_status_register)(const struct device *dev, enum tcpc_status_reg reg,
                        uint32_t mask);
        int (*mask_status_register)(const struct device *dev, enum tcpc_status_reg reg,
                        uint32_t mask);
        int (*set_debug_accessory)(const struct device *dev, bool enable);
        int (*set_debug_detach)(const struct device *dev);
        int (*set_drp_toggle)(const struct device *dev, bool enable);
        int (*get_snk_ctrl)(const struct device *dev);
        int (*set_snk_ctrl)(const struct device *dev, bool enable);
        int (*get_src_ctrl)(const struct device *dev);
        int (*set_src_ctrl)(const struct device *dev, bool enable);
        int (*get_chip_info)(const struct device *dev, struct tcpc_chip_info *chip_info);
        int (*set_low_power_mode)(const struct device *dev, bool enable);
        int (*sop_prime_enable)(const struct device *dev, bool enable);
        int (*set_bist_test_mode)(const struct device *dev, bool enable);
        int (*set_alert_handler_cb)(const struct device *dev, tcpc_alert_handler_cb_t handler,
                        void *data);
};
 
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 =
                (const struct tcpc_driver_api *)dev->api;
 
        __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 =
                (const struct tcpc_driver_api *)dev->api;
 
        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 =
        (const struct tcpc_driver_api *)dev->api;
 
        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 =
        (const struct tcpc_driver_api *)dev->api;
 
        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 =
                (const struct tcpc_driver_api *)dev->api;
 
        __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 tcpc_driver_api *api =
                (const struct tcpc_driver_api *)dev->api;
 
        __ASSERT(api->set_vconn_cb != NULL,
                 "Callback pointer should not be NULL");
 
        api->set_vconn_cb(dev, vconn_cb);
}
 
static inline void tcpc_set_vconn_discharge_cb(const struct device *dev,
                                     tcpc_vconn_discharge_cb_t cb)
{
        const struct tcpc_driver_api *api =
                (const struct tcpc_driver_api *)dev->api;
 
        __ASSERT(api->set_vconn_discharge_cb != NULL,
                 "Callback pointer should not be NULL");
 
        api->set_vconn_discharge_cb(dev, cb);
}
 
static inline int tcpc_vconn_discharge(const struct device *dev, bool enable)
{
        const struct tcpc_driver_api *api =
                (const struct tcpc_driver_api *)dev->api;
 
        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 =
                (const struct tcpc_driver_api *)dev->api;
 
        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 =
                (const struct tcpc_driver_api *)dev->api;
 
        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 = (const struct tcpc_driver_api *)dev->api;
 
        __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 =
                (const struct tcpc_driver_api *)dev->api;
 
        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 =
                (const struct tcpc_driver_api *)dev->api;
 
        __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 =
                (const struct tcpc_driver_api *)dev->api;
 
        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 =
                (const struct tcpc_driver_api *)dev->api;
 
        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 =
                (const struct tcpc_driver_api *)dev->api;
 
        __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,
                                           int32_t *status)
{
        const struct tcpc_driver_api *api =
                (const struct tcpc_driver_api *)dev->api;
 
        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 =
                (const struct tcpc_driver_api *)dev->api;
 
        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 =
                (const struct tcpc_driver_api *)dev->api;
 
        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 =
                (const struct tcpc_driver_api *)dev->api;
 
        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 =
                (const struct tcpc_driver_api *)dev->api;
 
        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 =
                (const struct tcpc_driver_api *)dev->api;
 
        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 =
                (const struct tcpc_driver_api *)dev->api;
 
        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 = (const struct tcpc_driver_api *)dev->api;
 
        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 =
                (const struct tcpc_driver_api *)dev->api;
 
        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 = (const struct tcpc_driver_api *)dev->api;
 
        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 =
                (const struct tcpc_driver_api *)dev->api;
 
        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 =
                (const struct tcpc_driver_api *)dev->api;
 
        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 =
                (const struct tcpc_driver_api *)dev->api;
 
        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 =
                (const struct tcpc_driver_api *)dev->api;
 
        if (api->sop_prime_enable == NULL) {
                return -ENOSYS;
        }
 
        return api->sop_prime_enable(dev, enable);
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_USBC_USBC_TCPC_H_ */