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 (*get_src_ctrl)(const struct device *dev);
 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");
 
 return 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");
 
 return 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_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_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_ */