usbc_ppc.h

Go to the documentation of this file.

/*
 * Copyright 2023 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_USB_C_USBC_PPC_H_
#define ZEPHYR_INCLUDE_DRIVERS_USB_C_USBC_PPC_H_

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

enum usbc_ppc_event {
        USBC_PPC_EVENT_DEAD_BATTERY_ERROR = 0,

        USBC_PPC_EVENT_SRC_OVERVOLTAGE,
        USBC_PPC_EVENT_SRC_REVERSE_CURRENT,
        USBC_PPC_EVENT_SRC_OVERCURRENT,
        USBC_PPC_EVENT_SRC_SHORT,

        USBC_PPC_EVENT_OVER_TEMPERATURE,
        USBC_PPC_EVENT_BOTH_SNKSRC_ENABLED,

        USBC_PPC_EVENT_SNK_REVERSE_CURRENT,
        USBC_PPC_EVENT_SNK_SHORT,
        USBC_PPC_EVENT_SNK_OVERVOLTAGE,
};

typedef void (*usbc_ppc_event_cb_t)(const struct device *dev, void *data, enum usbc_ppc_event ev);


__subsystem struct usbc_ppc_driver_api {
        int (*is_dead_battery_mode)(const struct device *dev);
        int (*exit_dead_battery_mode)(const struct device *dev);
        int (*is_vbus_source)(const struct device *dev);
        int (*is_vbus_sink)(const struct device *dev);
        int (*set_snk_ctrl)(const struct device *dev, bool enable);
        int (*set_src_ctrl)(const struct device *dev, bool enable);
        int (*set_vbus_discharge)(const struct device *dev, bool enable);
        int (*is_vbus_present)(const struct device *dev);
        int (*set_event_handler)(const struct device *dev, usbc_ppc_event_cb_t handler, void *data);
        int (*dump_regs)(const struct device *dev);
};

 
/*
 * API functions
 */

static inline int ppc_is_dead_battery_mode(const struct device *dev)
{
        const struct usbc_ppc_driver_api *api = DEVICE_API_GET(usbc_ppc, dev);
 
        if (api->is_dead_battery_mode == NULL) {
                return -ENOSYS;
        }
 
        return api->is_dead_battery_mode(dev);
}

static inline int ppc_exit_dead_battery_mode(const struct device *dev)
{
        const struct usbc_ppc_driver_api *api = DEVICE_API_GET(usbc_ppc, dev);
 
        if (api->exit_dead_battery_mode == NULL) {
                return -ENOSYS;
        }
 
        return api->exit_dead_battery_mode(dev);
}

static inline int ppc_is_vbus_source(const struct device *dev)
{
        const struct usbc_ppc_driver_api *api = DEVICE_API_GET(usbc_ppc, dev);
 
        if (api->is_vbus_source == NULL) {
                return -ENOSYS;
        }
 
        return api->is_vbus_source(dev);
}

static inline int ppc_is_vbus_sink(const struct device *dev)
{
        const struct usbc_ppc_driver_api *api = DEVICE_API_GET(usbc_ppc, dev);
 
        if (api->is_vbus_sink == NULL) {
                return -ENOSYS;
        }
 
        return api->is_vbus_sink(dev);
}

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

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

static inline int ppc_set_vbus_discharge(const struct device *dev, bool enable)
{
        const struct usbc_ppc_driver_api *api = DEVICE_API_GET(usbc_ppc, dev);
 
        if (api->set_vbus_discharge == NULL) {
                return -ENOSYS;
        }
 
        return api->set_vbus_discharge(dev, enable);
}

static inline int ppc_is_vbus_present(const struct device *dev)
{
        const struct usbc_ppc_driver_api *api = DEVICE_API_GET(usbc_ppc, dev);
 
        if (api->is_vbus_present == NULL) {
                return -ENOSYS;
        }
 
        return api->is_vbus_present(dev);
}

static inline int ppc_set_event_handler(const struct device *dev,
        usbc_ppc_event_cb_t handler, void *data)
{
        const struct usbc_ppc_driver_api *api = DEVICE_API_GET(usbc_ppc, dev);
 
        if (api->set_event_handler == NULL) {
                return -ENOSYS;
        }
 
        return api->set_event_handler(dev, handler, data);
}

static inline int ppc_dump_regs(const struct device *dev)
{
        const struct usbc_ppc_driver_api *api = DEVICE_API_GET(usbc_ppc, dev);
 
        if (api->dump_regs == NULL) {
                return -ENOSYS;
        }
 
        return api->dump_regs(dev);
}
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_DRIVERS_USB_C_USBC_PPC_H_ */