bq2429x.h

Go to the documentation of this file.

/*
 * Copyright (C) 2020 Locha Inc
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#ifndef BQ2429X_H
#define BQ2429X_H
 
#include <stdint.h>
#include <stdbool.h>
 
#include "kernel_defines.h"
#include "periph/i2c.h"
#include "periph/gpio.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum {
    BQ2429X_OK              = 0,        
    BQ2429X_ERR_I2C         = -1,       
    BQ2429X_ERR_GPIO        = -2,       
};
 
typedef enum {
    BQ2429X_VBUS_NONE   = 0,            
    BQ2429X_VBUS_USB_CHARGER,           
    BQ2429X_VBUS_AP_CHARGER,            
    BQ2429X_VBUS_OTG,                   
} bq2429x_vbus_stat_t;
 
typedef enum {
    BQ2429X_CHARGE_NONE = 0,            
    BQ2429X_CHARGE_PRE,                 
    BQ2429X_CHARGE_FAST,                
    BQ2429X_CHARGE_DONE,                
} bq2429x_chrg_stat_t;
 
typedef struct {
    bq2429x_vbus_stat_t vbus;   
    bq2429x_chrg_stat_t chrg;   
    bool dpm;
    bool pg;
    bool therm;
    bool vsys;
} bq2429x_status_t;
 
typedef enum {
    BQ2429x_CHRG_FAULT_NORMAL = 0,              
    BQ2429x_CHRG_FAULT_INPUT,                   
    BQ2429x_CHRG_FAULT_THERMAL_SHUTDOWN,        
    BQ2429x_CHRG_FAULT_CHARGE_TIMER_EXPIRATION, 
} bq2429x_chrg_fault_t;
 
typedef struct {
    bool watchdog;
    bool otg;
    bq2429x_chrg_fault_t chrg;
    bool bat;
    bool ntc_fault_1;
    bool ntc_fault_0;
} bq2429x_fault_t;
 
typedef enum {
    BQ2429X_VLIM_3880 = 0,              
    BQ2429X_VLIM_3960,                  
    BQ2429X_VLIM_4040,                  
    BQ2429X_VLIM_4120,                  
    BQ2429X_VLIM_4200,                  
    BQ2429X_VLIM_4280,                  
    BQ2429X_VLIM_4360,                  
    BQ2429X_VLIM_4440,                  
    BQ2429X_VLIM_4520,                  
    BQ2429X_VLIM_4600,                  
    BQ2429X_VLIM_4680,                  
    BQ2429X_VLIM_4760,                  
    BQ2429X_VLIM_4840,                  
    BQ2429X_VLIM_4920,                  
    BQ2429X_VLIM_5000,                  
    BQ2429X_VLIM_5080,                  
} bq2429x_input_voltage_limit_t;
 
typedef enum {
    BQ2429X_ILIM_100 = 0,               
    BQ2429X_ILIM_150,                   
    BQ2429X_ILIM_500,                   
    BQ2429X_ILIM_900,                   
    BQ2429X_ILIM_1000,                  
    BQ2429X_ILIM_1500,                  
    BQ2429X_ILIM_2000,                  
    BQ2429X_ILIM_3000,                  
} bq2429x_input_current_limit_t;
 
typedef enum {
    BQ2429X_ICHG_512    = 0,            
    BQ2429X_ICHG_1024   = 8,            
    BQ2429X_ICHG_2048   = 24,           
    BQ2429X_ICHG_3008   = 39,           
    BQ2429X_ICHG_4032   = 55,           
    BQ2429X_ICHG_4544   = 63,
} bq2429x_charge_current_t;
 
typedef enum {
    BQ2429X_VREG_3504   = 0,            
    BQ2429X_VREG_3600   = 6,            
    BQ2429X_VREG_3808   = 19,           
    BQ2429X_VREG_3904   = 25,           
    BQ2429X_VREG_4000   = 31,           
    BQ2429X_VREG_4112   = 38,           
    BQ2429X_VREG_4208   = 44,           
    BQ2429X_VREG_4304   = 50,           
    BQ2429X_VREG_4352   = 53,           
    BQ2429X_VREG_4400   = 56,           
} bq2429x_charge_voltage_limit_t;
 
typedef struct {
    i2c_t i2c;                              
#if IS_USED(MODULE_BQ2429X_INT)
    gpio_t int_pin;                         
#endif
    gpio_t ce_pin;                          
    gpio_t otg_pin;                         
    bq2429x_input_voltage_limit_t vlim;     
    bq2429x_input_current_limit_t ilim;     
    bq2429x_charge_current_t ichg;          
    bq2429x_charge_voltage_limit_t vreg;    
} bq2429x_params_t;
 
typedef struct {
    bq2429x_params_t params;            
} bq2429x_t;
 
int bq2429x_init(bq2429x_t *dev, const bq2429x_params_t *params);
 
#if IS_USED(MODULE_BQ2429X_INT) || DOXYGEN
typedef void (* bq2429x_int_cb_t)(void *);
 
int bq2429x_init_int(bq2429x_t *dev, bq2429x_int_cb_t cb, void *arg);
#endif /* IS_USED(MODULE_BQ2429X_INT) || DOXYGEN */
 
int bq2429x_get_status(const bq2429x_t *dev, bq2429x_status_t *status);
 
int bq2429x_get_fault(const bq2429x_t *dev, bq2429x_fault_t *fault);
 
int bq2429x_enable_otg(const bq2429x_t *dev);
 
int bq2429x_disable_otg(const bq2429x_t *dev);
 
int bq2429x_enable_charge(const bq2429x_t *dev);
 
int bq2429x_disable_charge(const bq2429x_t *dev);
 
int bq2429x_set_vlim(bq2429x_t *dev, bq2429x_input_voltage_limit_t vlim);
 
int bq2429x_get_vlim(const bq2429x_t *dev, bq2429x_input_voltage_limit_t *vlim);
 
int bq2429x_set_ilim(bq2429x_t *dev, bq2429x_input_current_limit_t ilim);
 
int bq2429x_get_ilim(const bq2429x_t *dev, bq2429x_input_current_limit_t *ilim);
 
int bq2429x_set_ichg(bq2429x_t *dev, bq2429x_charge_current_t ichg);
 
int bq2429x_get_ichg(const bq2429x_t *dev, bq2429x_charge_current_t *ichg);
 
int bq2429x_set_vreg(bq2429x_t *dev, bq2429x_charge_voltage_limit_t vreg);
 
int bq2429x_get_vreg(const bq2429x_t *dev,
                     bq2429x_charge_voltage_limit_t *vreg);
 
#ifdef __cplusplus
}
#endif
 
#endif /* BQ2429X_H */