charger.h

Go to the documentation of this file.

/*
 * Copyright 2023 Cirrus Logic, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DRIVERS_CHARGER_H_
#define ZEPHYR_INCLUDE_DRIVERS_CHARGER_H_
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include <zephyr/device.h>
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
enum charger_property {
        CHARGER_PROP_ONLINE = 0,
        CHARGER_PROP_PRESENT,
        CHARGER_PROP_STATUS,
        CHARGER_PROP_CHARGE_TYPE,
        CHARGER_PROP_HEALTH,
        CHARGER_PROP_CONSTANT_CHARGE_CURRENT_UA,
        CHARGER_PROP_PRECHARGE_CURRENT_UA,
        CHARGER_PROP_CHARGE_TERM_CURRENT_UA,
        CHARGER_PROP_CONSTANT_CHARGE_VOLTAGE_UV,
        CHARGER_PROP_INPUT_REGULATION_CURRENT_UA,
        CHARGER_PROP_INPUT_REGULATION_VOLTAGE_UV,
        CHARGER_PROP_INPUT_CURRENT_NOTIFICATION,
        CHARGER_PROP_COMMON_COUNT,
        CHARGER_PROP_CUSTOM_BEGIN = CHARGER_PROP_COMMON_COUNT + 1,
        CHARGER_PROP_MAX = UINT16_MAX,
};
 
typedef uint16_t charger_prop_t;
 
enum charger_online {
        CHARGER_ONLINE_OFFLINE = 0,
        CHARGER_ONLINE_FIXED,
        CHARGER_ONLINE_PROGRAMMABLE,
};
 
enum charger_status {
        CHARGER_STATUS_UNKNOWN = 0,
        CHARGER_STATUS_CHARGING,
        CHARGER_STATUS_DISCHARGING,
        CHARGER_STATUS_NOT_CHARGING,
        CHARGER_STATUS_FULL,
};
 
enum charger_charge_type {
        CHARGER_CHARGE_TYPE_UNKNOWN = 0,
        CHARGER_CHARGE_TYPE_NONE,
        CHARGER_CHARGE_TYPE_TRICKLE,
        CHARGER_CHARGE_TYPE_FAST,
        CHARGER_CHARGE_TYPE_STANDARD,
        /*
         * Charging is being dynamically adjusted by the charger device
         */
        CHARGER_CHARGE_TYPE_ADAPTIVE,
        /*
         * Charging is occurring at a reduced charge rate to preserve
         * battery health
         */
        CHARGER_CHARGE_TYPE_LONGLIFE,
        /*
         * The charger device is being bypassed and the power conversion
         * is being handled externally, typically by a "smart" wall adaptor
         */
        CHARGER_CHARGE_TYPE_BYPASS,
};
 
enum charger_health {
        CHARGER_HEALTH_UNKNOWN = 0,
        CHARGER_HEALTH_GOOD,
        CHARGER_HEALTH_OVERHEAT,
        CHARGER_HEALTH_OVERVOLTAGE,
        CHARGER_HEALTH_UNSPEC_FAILURE,
        CHARGER_HEALTH_COLD,
        CHARGER_HEALTH_WATCHDOG_TIMER_EXPIRE,
        CHARGER_HEALTH_SAFETY_TIMER_EXPIRE,
        CHARGER_HEALTH_CALIBRATION_REQUIRED,
        CHARGER_HEALTH_WARM,
        CHARGER_HEALTH_COOL,
        CHARGER_HEALTH_HOT,
        CHARGER_HEALTH_NO_BATTERY,
};
 
enum charger_notification_severity {
        CHARGER_SEVERITY_PEAK = 0,
        CHARGER_SEVERITY_CRITICAL,
        CHARGER_SEVERITY_WARNING,
};
 
struct charger_current_notifier {
        uint8_t severity;
        uint32_t current_ua;
        uint32_t duration_us;
};
 
union charger_propval {
        /* Fields have the format: */
        /* CHARGER_PROPERTY_FIELD */
        /* type property_field; */
 
        enum charger_online online;
        bool present;
        enum charger_status status;
        enum charger_charge_type charge_type;
        enum charger_health health;
        uint32_t const_charge_current_ua;
        uint32_t precharge_current_ua;
        uint32_t charge_term_current_ua;
        uint32_t const_charge_voltage_uv;
        uint32_t input_current_regulation_current_ua;
        uint32_t input_voltage_regulation_voltage_uv;
        struct charger_current_notifier input_current_notification;
};
 
typedef int (*charger_get_property_t)(const struct device *dev, const charger_prop_t prop,
                                      union charger_propval *val);
 
typedef int (*charger_set_property_t)(const struct device *dev, const charger_prop_t prop,
                                      const union charger_propval *val);
 
typedef int (*charger_charge_enable_t)(const struct device *dev, const bool enable);
 
__subsystem struct charger_driver_api {
        charger_get_property_t get_property;
        charger_set_property_t set_property;
        charger_charge_enable_t charge_enable;
};
 
__syscall int charger_get_prop(const struct device *dev, const charger_prop_t prop,
                               union charger_propval *val);
 
static inline int z_impl_charger_get_prop(const struct device *dev, const charger_prop_t prop,
                                          union charger_propval *val)
{
        const struct charger_driver_api *api = (const struct charger_driver_api *)dev->api;
 
        return api->get_property(dev, prop, val);
}
 
__syscall int charger_set_prop(const struct device *dev, const charger_prop_t prop,
                               const union charger_propval *val);
 
static inline int z_impl_charger_set_prop(const struct device *dev, const charger_prop_t prop,
                                          const union charger_propval *val)
{
        const struct charger_driver_api *api = (const struct charger_driver_api *)dev->api;
 
        return api->set_property(dev, prop, val);
}
 
__syscall int charger_charge_enable(const struct device *dev, const bool enable);
 
static inline int z_impl_charger_charge_enable(const struct device *dev, const bool enable)
{
        const struct charger_driver_api *api = (const struct charger_driver_api *)dev->api;
 
        return api->charge_enable(dev, enable);
}
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#include <syscalls/charger.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_CHARGER_H_ */