421 lines
13 KiB
C
Executable File
421 lines
13 KiB
C
Executable File
/*
|
||
* Copyright (C) 2017 XRADIO TECHNOLOGY CO., LTD. All rights reserved.
|
||
*
|
||
* Redistribution and use in source and binary forms, with or without
|
||
* modification, are permitted provided that the following conditions
|
||
* are met:
|
||
* 1. Redistributions of source code must retain the above copyright
|
||
* notice, this list of conditions and the following disclaimer.
|
||
* 2. Redistributions in binary form must reproduce the above copyright
|
||
* notice, this list of conditions and the following disclaimer in the
|
||
* documentation and/or other materials provided with the
|
||
* distribution.
|
||
* 3. Neither the name of XRADIO TECHNOLOGY CO., LTD. nor the names of
|
||
* its contributors may be used to endorse or promote products derived
|
||
* from this software without specific prior written permission.
|
||
*
|
||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||
*/
|
||
|
||
#include "common/cmd/cmd_util.h"
|
||
#include "cmd_axp.h"
|
||
#include "pm/pm.h"
|
||
#include "driver/component/axp/axp.h"
|
||
#include "driver/component/axp/axp_common.h"
|
||
#include "driver/component/axp/axp_power_supply.h"
|
||
#include "driver/chip/hal_gpio.h"
|
||
|
||
#ifdef CONFIG_AXP_CORE
|
||
|
||
#ifndef ARRAY_SIZE
|
||
#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
|
||
#endif
|
||
|
||
static enum cmd_status cmd_axp_write_reg_exec(char *cmd)
|
||
{
|
||
uint32_t cnt, reg, val;
|
||
int ret = 0;
|
||
cnt = cmd_sscanf(cmd, "%x %x", ®, &val);
|
||
if (cnt != 2) {
|
||
CMD_AXP_ERR("invalid param number %d\r\n", cnt);
|
||
return CMD_STATUS_INVALID_ARG;
|
||
}
|
||
CMD_AXP_DBG("r=%d v=%d\r\n", reg, val);
|
||
ret = axp_write_reg(reg, val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp write reg error\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
|
||
return CMD_STATUS_OK;
|
||
}
|
||
|
||
static enum cmd_status cmd_axp_read_reg_exec(char *cmd)
|
||
{
|
||
uint32_t reg, cnt;
|
||
uint8_t val;
|
||
int ret = 0;
|
||
cnt = cmd_sscanf(cmd, "%x", ®);
|
||
if (cnt != 1) {
|
||
CMD_AXP_ERR("invalid param number %d\r\n", cnt);
|
||
return CMD_STATUS_INVALID_ARG;
|
||
}
|
||
ret = axp_read_reg((uint8_t)reg, &val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp read reg error\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_DBG("val = 0x%x\r\n", val);
|
||
return CMD_STATUS_OK;
|
||
}
|
||
|
||
static enum cmd_status cmd_axp_set_voltage_exec(char *cmd)
|
||
{
|
||
char name[64];
|
||
uint32_t cnt;
|
||
int ret = 0;
|
||
int voltage = 0, onoff = 0;
|
||
cnt = cmd_sscanf(cmd, "%s %d %d", name, &voltage, &onoff);
|
||
if (cnt != 3) {
|
||
CMD_AXP_ERR("invalid param number %d\r\n", cnt);
|
||
return CMD_STATUS_INVALID_ARG;
|
||
}
|
||
CMD_AXP_DBG("name %s,voltage %d,onoff %d\r\n", name, voltage, onoff);
|
||
ret = axp_set_voltage(name, voltage, onoff);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp set voltage error\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
return CMD_STATUS_OK;
|
||
}
|
||
|
||
static enum cmd_status cmd_axp_get_voltage_exec(char *cmd)
|
||
{
|
||
char name[64];
|
||
uint32_t cnt;
|
||
int voltage = 0;
|
||
int ret = 0;
|
||
cnt = cmd_sscanf(cmd, "%s", name);
|
||
if (cnt != 1) {
|
||
CMD_AXP_ERR("invalid param number %d\r\n", cnt);
|
||
return CMD_STATUS_INVALID_ARG;
|
||
}
|
||
ret = axp_get_voltage(name, &voltage);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp get voltage error\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_DBG("name %s,voltage %d\r\n", name, voltage);
|
||
return CMD_STATUS_OK;
|
||
}
|
||
|
||
static enum cmd_status cmd_axp_close_all_power_exec(char *cmd)
|
||
{
|
||
int ret = 0;
|
||
ret = axp_poweroff();
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp poweroff error\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
return CMD_STATUS_OK;
|
||
}
|
||
|
||
static enum cmd_status cmd_axp_open_all_power_exec(char *cmd)
|
||
{
|
||
int ret = 0;
|
||
ret = axp_poweron(false);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp poweron error\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
return CMD_STATUS_OK;
|
||
}
|
||
|
||
static enum cmd_status cmd_axp_get_poweron_source_exec(char *cmd)
|
||
{
|
||
enum axp_boot_source poweron_source = axp_get_poweron_source();
|
||
switch (poweron_source) {
|
||
case AXP_BOOT_SOURCE_BUTTON:
|
||
CMD_AXP_DBG("poweron source is button\r\n");
|
||
break;
|
||
case AXP_BOOT_SOURCE_IRQ_LOW:
|
||
CMD_AXP_DBG("poweron source is irq\r\n");
|
||
break;
|
||
case AXP_BOOT_SOURCE_VBUS_USB:
|
||
CMD_AXP_DBG("poweron source is vbus\r\n");
|
||
break;
|
||
case AXP_BOOT_SOURCE_CHARGER:
|
||
CMD_AXP_DBG("poweron source is charger\r\n");
|
||
break;
|
||
case AXP_BOOT_SOURCE_BATTERY:
|
||
CMD_AXP_DBG("poweron source is battery\r\n");
|
||
break;
|
||
case AXP_BOOT_SOURCE_UNKOWN:
|
||
CMD_AXP_DBG("poweron source is unknow\r\n");
|
||
break;
|
||
}
|
||
|
||
return CMD_STATUS_OK;
|
||
}
|
||
|
||
static enum cmd_status cmd_axp_set_vbus_voltage_exec(char *cmd)
|
||
{
|
||
uint32_t cnt;
|
||
int ret = 0;
|
||
int voltage = 0;
|
||
cnt = cmd_sscanf(cmd, "%d", &voltage);
|
||
if (cnt != 1) {
|
||
CMD_AXP_ERR("invalid param number %d\r\n", cnt);
|
||
return CMD_STATUS_INVALID_ARG;
|
||
}
|
||
ret = axp_set_vbus_vol_limit(voltage);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp set voltage limit error\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_DBG("voltage %d\r\n", voltage);
|
||
return CMD_STATUS_OK;
|
||
}
|
||
|
||
static enum cmd_status cmd_axp_get_vbus_voltage_exec(char *cmd)
|
||
{
|
||
int ret = 0;
|
||
int voltage = 0;
|
||
ret = axp_get_vbus_vol_limit(&voltage);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp get vbus voltage limit error\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_DBG("get vbus voltage limit %d mv\r\n", voltage);
|
||
return CMD_STATUS_OK;
|
||
}
|
||
|
||
static enum cmd_status cmd_axp_dump_whole_reg(char *cmd)
|
||
{
|
||
axp_dump_whole_reg();
|
||
return CMD_STATUS_OK;
|
||
}
|
||
|
||
static enum cmd_status cmd_axp_get_bat_property(char *cmd)
|
||
{
|
||
int ret;
|
||
union power_supply_propval *val = malloc(128);
|
||
if (NULL == val) {
|
||
CMD_AXP_ERR("%s, malloc memory error\r\n", __func__);
|
||
return -1;
|
||
}
|
||
|
||
memset(val, 0x00, 128);
|
||
|
||
/* 获取电池状态，返回值：int，1：电池存在，0：电池不存在 */
|
||
ret = axp_get_battery_property(POWER_SUPPLY_PROP_PRESENT, val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp get Battery preset failed\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_INF("Battery present: %d\r\n", val->intval);
|
||
|
||
/* 获取电池电压，返回值：int: unit uV;*/
|
||
ret = axp_get_battery_property(POWER_SUPPLY_PROP_VOLTAGE_NOW, val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp get Battery voltage failed\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_INF("Battery voltage: %d\r\n", val->intval);
|
||
|
||
/* 获取电池的容量，返回值：int */
|
||
ret = axp_get_battery_property(POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp get Battery energy_full_design failed\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_INF("Battery energy_full_design: %d\r\n", val->intval);
|
||
|
||
/* 获取电池充电状态：返回值：str
|
||
* charging
|
||
* discharging
|
||
* not_charging
|
||
* charged_full
|
||
* */
|
||
ret = axp_get_battery_property(POWER_SUPPLY_PROP_STATUS, val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp get Battery charger status failed\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_INF("Battery charger status: %s\r\n", val->strval);
|
||
|
||
/* 获取电池设置的低电量警告值，返回值：int unit%*/
|
||
ret = axp_get_battery_property(POWER_SUPPLY_PROP_CAPACITY_ALERT_MIN, val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp get Battery capacity_alert min failed\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_INF("Battery capacity_alert min: %d\r\n", val->intval);
|
||
|
||
/* 获取电池温度，返回值:int --unit degree celsius*/
|
||
ret = axp_get_battery_property(POWER_SUPPLY_PROP_TEMP, val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp get Battery temp failed\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_INF("Battery temp: %d\r\n", val->intval);
|
||
|
||
/* 获取电池当前剩余容量：返回值：int */
|
||
ret = axp_get_battery_property(POWER_SUPPLY_PROP_CAPACITY, val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp get Battery status failed\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_INF("Battery capacity: %d\r\n", val->intval);
|
||
|
||
/* 获取设置电池的低温关机：返回值：int --得到的值要除于10
|
||
* 和POWER_SUPPLY_PROP_TEMP_AMBIENT_MIN一样 */
|
||
ret = axp_get_battery_property(POWER_SUPPLY_PROP_TEMP_ALERT_MIN, val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp get Battery status failed\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_INF("Battery TEMP_ALERT_MIN: %d\r\n", val->intval);
|
||
|
||
/* 获取设置电池的高温关机值：返回值：int --除于10为度
|
||
* 和POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MAX一样 */
|
||
ret = axp_get_battery_property(POWER_SUPPLY_PROP_TEMP_ALERT_MAX, val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp get Battery status failed\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_INF("Battery TEMP_ALERT_MAX: %d\r\n", val->intval);
|
||
|
||
/* 获取设置电池的低温停冲值：返回值：int -- 除于10为度
|
||
* 和POWER_SUPPLY_PROP_TEMP_MIN一样 */
|
||
ret = axp_get_battery_property(POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MIN, val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp get Battery TEMP_AMBIENT_ALERT_MIN failed\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_INF("Battery TEMP_AMBIENT_ALERT_MIN: %d\r\n", val->intval);
|
||
|
||
/* 获取设置电池的高温停冲值：返回值：int --除于10为度
|
||
* 和POWER_SUPPLY_PROP_TEMP_ALERT_MAX一样 */
|
||
ret = axp_get_battery_property(POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MAX, val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp get Battery TEMP_AMBIENT_ALERT_MAX failed\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_INF("Battery TEMP_AMBIENT_ALERT_MAX: %d\r\n", val->intval);
|
||
|
||
/* 获取电池的放电时间，返回int --unit second */
|
||
ret = axp_get_battery_property(POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp get Battery TIME_TO_EMPTY failed\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_INF("Battery TIME_TO_EMPTY: %d\r\n", val->intval);
|
||
|
||
/* 获取还有多少时间充满电，返回int --unit second*/
|
||
ret = axp_get_battery_property(POWER_SUPPLY_PROP_TIME_TO_FULL_NOW, val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp get Battery T2F failed\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_INF("Battery chargering T2F: %d\r\n", val->intval);
|
||
|
||
/* 获取目前使用哪款BMU的名字，返回str */
|
||
ret = axp_get_battery_property(POWER_SUPPLY_PROP_MANUFACTURER, val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp get Battery nmu name failed\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_INF("Battery bmu name: %s\r\n", val->strval);
|
||
|
||
/* 获取电池目前的电流电量等级，返回str
|
||
* 充满为full
|
||
* 大于80返回high
|
||
* 大于warning_level1为normal
|
||
* 大于warning_level2为low
|
||
* 低于warning_level2为严重返回:critical
|
||
* */
|
||
ret = axp_get_battery_property(POWER_SUPPLY_PROP_CAPACITY_LEVEL, val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp get Battery capacity_level failed\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_INF("Battery capacity_level: %s\r\n", val->strval);
|
||
|
||
/* 获取VBUS的状态,返回值：int 1:online 0: not online */
|
||
ret = axp_get_battery_property(POWER_SUPPLY_PROP_ONLINE, val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("axp get Battery VBUS status failed\r\n");
|
||
return CMD_STATUS_FAIL;
|
||
}
|
||
CMD_AXP_INF("Battery VBUS STATUS: %d\r\n", val->intval);
|
||
|
||
return CMD_STATUS_OK;
|
||
}
|
||
|
||
/* axp cmd_axp_set_charger_cur cur_val
|
||
* cur_val step:25mv or 100mv
|
||
* */
|
||
|
||
static enum cmd_status cmd_axp_set_charger_cur(char *cmd)
|
||
{
|
||
int val, cnt;
|
||
int ret = 0;
|
||
cnt = cmd_sscanf(cmd, "%d", &val);
|
||
if (cnt != 1) {
|
||
CMD_AXP_ERR("invalid param number %d\r\n", cnt);
|
||
return CMD_STATUS_INVALID_ARG;
|
||
}
|
||
|
||
ret = axp_set_charger_cur(val);
|
||
if (ret < 0) {
|
||
CMD_AXP_ERR("set charger current error\r\n");
|
||
}
|
||
return CMD_STATUS_OK;
|
||
}
|
||
|
||
static enum cmd_status cmd_axp_get_charger_cur(char *cmd)
|
||
{
|
||
int val;
|
||
val = axp_get_charger_cur();
|
||
if (val < 0) {
|
||
CMD_AXP_ERR("get charger current error\r\n");
|
||
} else {
|
||
CMD_AXP_INF("get charger current limit %d\r\n", val);
|
||
}
|
||
return CMD_STATUS_OK;
|
||
}
|
||
|
||
static const struct cmd_data g_axp_cmds[] = {
|
||
{ "poweron", cmd_axp_open_all_power_exec},
|
||
{ "poweroff", cmd_axp_close_all_power_exec},
|
||
{ "read_reg", cmd_axp_read_reg_exec},
|
||
{ "write_reg", cmd_axp_write_reg_exec},
|
||
{ "set_voltage", cmd_axp_set_voltage_exec},
|
||
{ "get_voltage", cmd_axp_get_voltage_exec},
|
||
{ "get_poweron_source", cmd_axp_get_poweron_source_exec},
|
||
{ "set_vbus_voltage_limit", cmd_axp_set_vbus_voltage_exec},
|
||
{ "get_vbus_voltage_limit", cmd_axp_get_vbus_voltage_exec},
|
||
{ "dump_reg", cmd_axp_dump_whole_reg},
|
||
{ "get_bat_status", cmd_axp_get_bat_property},
|
||
{ "set_charger_cur", cmd_axp_set_charger_cur},
|
||
{ "get_charger_cur", cmd_axp_get_charger_cur},
|
||
};
|
||
|
||
enum cmd_status cmd_axp_exec(char *cmd)
|
||
{
|
||
return cmd_exec(cmd, g_axp_cmds, cmd_nitems(g_axp_cmds));
|
||
}
|
||
|
||
#endif /* CONFIG_AXP_CORE */
|