tcpm.h

/* Copyright 2015 The Chromium OS Authors. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
/* USB Power delivery port management - common header for TCPM drivers */
 
#ifndef __CROS_EC_USB_PD_TCPM_TCPM_H
#define __CROS_EC_USB_PD_TCPM_TCPM_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include "../drivers/tcpm_driver.h"
#include "usb_pd_tcpm.h"
 
#include "../config.h"
 
#if defined(CONFIG_USB_PD_DUAL_ROLE_AUTO_TOGGLE) && !defined(CONFIG_USB_PD_DUAL_ROLE)
#error "DRP auto toggle requires board to have DRP support"
#error "Please upgrade your board configuration"
#endif
 
#ifndef CONFIG_USB_PD_TCPC
  extern const struct tcpc_config_t tcpc_config;
 
  /* I2C wrapper functions - get I2C port / slave addr from config struct. */
  int tcpc_write(int reg, int val);
  int tcpc_read(int reg, int* val);
  int tcpc_xfer(const uint8_t* out, int out_size, uint8_t* in, int in_size, int flags);
  int tcpc_xfer_unlocked(const uint8_t* out, int out_size, uint8_t* in, int in_size, int flags);
  void tcpc_lock(int lock);
 
  /* TCPM driver wrapper function */
  static inline int tcpm_init()
  {
    int rv;
 
    rv = tcpc_config.drv->init();
    if (rv)
      return rv;
 
    /* Board specific post TCPC init */
    if (board_tcpc_post_init)
      rv = board_tcpc_post_init();
 
    return rv;
  }
 
  static inline int tcpm_release() { return tcpc_config.drv->release(); }
 
  static inline int tcpm_get_cc(enum tcpc_cc_voltage_status* cc1, enum tcpc_cc_voltage_status* cc2)
  {
    return tcpc_config.drv->get_cc(cc1, cc2);
  }
 
  static inline int tcpm_get_vbus_level(enum vbus_level level)
  {
    if (tcpc_config.drv->get_vbus_level)
      return tcpc_config.drv->get_vbus_level(level);
    // return 0 instead of a ptentially confusing error
    return 0;
  }
 
  static inline int tcpm_get_vbus_voltage()
  {
    // TODO: check returned error
    int vbus = 0;
    if (tcpc_config.drv->get_vbus_voltage)
    {
      tcpc_config.drv->get_vbus_voltage(&vbus);
    }
    return vbus;
  }
 
  static inline int tcpm_select_rp_value(int rp) { return tcpc_config.drv->select_rp_value(rp); }
 
  static inline int tcpm_set_cc(int pull) { return tcpc_config.drv->set_cc(pull); }
 
  static inline int tcpm_set_polarity(enum tcpc_cc_polarity polarity)
  {
    return tcpc_config.drv->set_polarity(polarity);
  }
 
  static inline int tcpm_set_vconn(int enable) { return tcpc_config.drv->set_vconn(enable); }
 
  static inline int tcpm_set_msg_header(int power_role, int data_role)
  {
    return tcpc_config.drv->set_msg_header(power_role, data_role);
  }
 
  static inline int tcpm_set_rx_enable(int enable) { return tcpc_config.drv->set_rx_enable(enable); }
 
  static inline void tcpm_enable_auto_discharge_disconnect(int enable)
  {
    const struct tcpm_drv* tcpc = tcpc_config.drv;
 
    if (tcpc->tcpc_enable_auto_discharge_disconnect)
      tcpc->tcpc_enable_auto_discharge_disconnect(enable);
  }
 
  static inline int tcpm_get_message(uint32_t* payload, uint32_t* head)
  {
    return tcpc_config.drv->get_message(payload, head);
  }
 
  static inline int tcpm_transmit(enum tcpm_transmit_type type, uint16_t header, const uint32_t* data)
  {
    return tcpc_config.drv->transmit(type, header, data);
  }
 
  static inline void tcpc_alert() { tcpc_config.drv->tcpc_alert(); }
 
  static inline void tcpc_discharge_vbus(int enable) { tcpc_config.drv->tcpc_discharge_vbus(enable); }
 
#ifdef CONFIG_USB_PD_DUAL_ROLE_AUTO_TOGGLE
  static inline int tcpm_auto_toggle_supported() { return !!tcpc_config.drv->drp_toggle; }
 
  static inline int tcpm_enable_drp_toggle() { return tcpc_config.drv->drp_toggle(); }
#endif
 
#ifdef CONFIG_USB_PD_TCPC_LOW_POWER
  static inline int tcpm_enter_low_power_mode() { return tcpc_config.drv->enter_low_power_mode(); }
#else
  int tcpm_enter_low_power_mode();
#endif
 
#ifdef CONFIG_CMD_I2C_STRESS_TEST_TCPC
  static inline int tcpc_i2c_read(const const int addr, const int reg, int* data) { return tcpc_read(reg, data); }
 
  static inline int tcpc_i2c_write(const const int addr, const int reg, int data) { return tcpc_write(reg, data); }
#endif
 
  static inline int tcpm_get_chip_info(int renew, struct ec_response_pd_chip_info** info)
  {
    if (tcpc_config.drv->get_chip_info)
      return tcpc_config.drv->get_chip_info(renew, info);
    return EC_ERROR_UNIMPLEMENTED;
  }
 
#else
 
int tcpm_init();
 
int tcpm_get_cc(int* cc1, int* cc2);
 
int tcpm_get_vbus_level(enum vbus_level level);
 
int tcpm_select_rp_value(int rp);
 
int tcpm_set_cc(int pull);
 
int tcpm_set_polarity(int polarity);
 
int tcpm_set_vconn(int enable);
 
int tcpm_set_msg_header(int power_role, int data_role);
 
int tcpm_set_rx_enable(int enable);
 
int tcpm_get_message(uint32_t* payload, int* head);
 
int tcpm_transmit(enum tcpm_transmit_type type, uint16_t header, const uint32_t* data);
 
void tcpc_alert();
 
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif