nathan/CoolPi-Armbian-Rockchip-RK3588-Upstream-Linux-6.1-LTS-Kernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
CoolPi-Armbian-Rockchip-RK3.../sound/soc/codecs/aw87xxx/aw_monitor.c

1189 lines
30 KiB
C
Raw Blame History

/*
* aw_monitor.c
*
* Copyright (c) 2021 AWINIC Technology CO., LTD
*
* Author: Barry <zhaozhongbo@awinic.com>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*/
#include <linux/module.h>
#include <linux/uaccess.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/power_supply.h>
#include <linux/of.h>
#include <linux/power_supply.h>
#include <linux/hrtimer.h>
#include <linux/i2c.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/firmware.h>
#include <linux/platform_device.h>
#include <linux/proc_fs.h>
#include <linux/io.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/dma-mapping.h>
#include <linux/gameport.h>
#include <linux/moduleparam.h>
#include <linux/mutex.h>
#include <linux/workqueue.h>
#include "aw87xxx.h"
#include "aw_log.h"
#include "aw_monitor.h"
#include "aw_dsp.h"
#include "aw_bin_parse.h"
#include "aw_device.h"
#define AW_MONITOT_BIN_PARSE_VERSION "V0.1.0"
#define AW_GET_32_DATA(w, x, y, z) \
((uint32_t)((((uint8_t)w) << 24) | (((uint8_t)x) << 16) | \
(((uint8_t)y) << 8) | ((uint8_t)z)))
/****************************************************************************
*
* aw87xxx monitor bin check
*
****************************************************************************/
static int aw_monitor_check_header_v_1_0_0(struct device *dev,
char *data, uint32_t data_len)
{
int i = 0;
struct aw_bin_header *header = (struct aw_bin_header *)data;
if (header->bin_data_type != DATA_TYPE_MONITOR_ANALOG) {
AW_DEV_LOGE(dev, "monitor data_type check error!");
return -EINVAL;
}
if (header->bin_data_size != AW_MONITOR_HDR_DATA_SIZE) {
AW_DEV_LOGE(dev, "monitor data_size error!");
return -EINVAL;
}
if (header->data_byte_len != AW_MONITOR_HDR_DATA_BYTE_LEN) {
AW_DEV_LOGE(dev, "monitor data_byte_len error!");
return -EINVAL;
}
for (i = 0; i < AW_MONITOR_DATA_VER_MAX; i++) {
if (header->bin_data_ver == i) {
AW_LOGD("monitor bin_data_ver[0x%x]", i);
break;
}
}
if (i == AW_MONITOR_DATA_VER_MAX)
return -EINVAL;
return 0;
}
static int aw_monitor_check_data_v1_size(struct device *dev,
char *data, int32_t data_len)
{
int32_t bin_header_len = sizeof(struct aw_bin_header);
int32_t monitor_header_len = sizeof(struct aw_monitor_header);
int32_t monitor_data_len = sizeof(struct vmax_step_config);
int32_t len = 0;
struct aw_monitor_header *monitor_header = NULL;
AW_DEV_LOGD(dev, "enter");
if (data_len < bin_header_len + monitor_header_len) {
AW_DEV_LOGE(dev, "bin len is less than aw_bin_header and monitoor_header,check failed");
return -EINVAL;
}
monitor_header = (struct aw_monitor_header *)(data + bin_header_len);
len = data_len - bin_header_len - monitor_header_len;
if (len < monitor_header->step_count * monitor_data_len) {
AW_DEV_LOGE(dev, "bin data len is not enough,check failed");
return -EINVAL;
}
AW_DEV_LOGD(dev, "succeed");
return 0;
}
static int aw_monitor_check_data_size(struct device *dev,
char *data, int32_t data_len)
{
int ret = -1;
struct aw_bin_header *header = (struct aw_bin_header *)data;
switch (header->bin_data_ver) {
case AW_MONITOR_DATA_VER:
ret = aw_monitor_check_data_v1_size(dev, data, data_len);
if (ret < 0)
return ret;
break;
default:
AW_DEV_LOGE(dev, "bin data_ver[0x%x] non support",
header->bin_data_ver);
return -EINVAL;
}
return 0;
}
static int aw_monitor_check_bin_header(struct device *dev,
char *data, int32_t data_len)
{
int ret = -1;
struct aw_bin_header *header = NULL;
if (data_len < sizeof(struct aw_bin_header)) {
AW_DEV_LOGE(dev, "bin len is less than aw_bin_header,check failed");
return -EINVAL;
}
header = (struct aw_bin_header *)data;
switch (header->header_ver) {
case HEADER_VERSION_1_0_0:
ret = aw_monitor_check_header_v_1_0_0(dev, data, data_len);
if (ret < 0) {
AW_DEV_LOGE(dev, "monitor bin haeder info check error!");
return ret;
}
break;
default:
AW_DEV_LOGE(dev, "bin version[0x%x] non support",
header->header_ver);
return -EINVAL;
}
return 0;
}
static int aw_monitor_bin_check_sum(struct device *dev,
char *data, int32_t data_len)
{
int i, data_sum = 0;
uint32_t *check_sum = (uint32_t *)data;
for (i = 4; i < data_len; i++)
data_sum += data[i];
if (*check_sum != data_sum) {
AW_DEV_LOGE(dev, "check_sum[%d] is not equal to data_sum[%d]",
*check_sum, data_sum);
return -ENOMEM;
}
AW_DEV_LOGD(dev, "succeed");
return 0;
}
static int aw_monitor_bin_check(struct device *dev,
char *monitor_data, uint32_t data_len)
{
int ret = -1;
if (monitor_data == NULL || data_len == 0) {
AW_DEV_LOGE(dev, "none data to parse");
return -EINVAL;
}
ret = aw_monitor_bin_check_sum(dev, monitor_data, data_len);
if (ret < 0) {
AW_DEV_LOGE(dev, "bin data check sum failed");
return ret;
}
ret = aw_monitor_check_bin_header(dev, monitor_data, data_len);
if (ret < 0) {
AW_DEV_LOGE(dev, "bin data len check failed");
return ret;
}
ret = aw_monitor_check_data_size(dev, monitor_data, data_len);
if (ret < 0) {
AW_DEV_LOGE(dev, "bin header info check failed");
return ret;
}
return 0;
}
/*****************************************************************************
*
* aw87xxx monitor header bin parse
*
*****************************************************************************/
static void aw_monitor_write_to_table_v1(struct device *dev,
struct vmax_step_config *vmax_step,
char *vmax_data, uint32_t step_count)
{
int i = 0;
int index = 0;
int vmax_step_size = (int)sizeof(struct vmax_step_config);
for (i = 0; i < step_count; i++) {
index = vmax_step_size * i;
vmax_step[i].vbat_min =
AW_GET_32_DATA(vmax_data[index + 3],
vmax_data[index + 2],
vmax_data[index + 1],
vmax_data[index + 0]);
vmax_step[i].vbat_max =
AW_GET_32_DATA(vmax_data[index + 7],
vmax_data[index + 6],
vmax_data[index + 5],
vmax_data[index + 4]);
vmax_step[i].vmax_vol =
AW_GET_32_DATA(vmax_data[index + 11],
vmax_data[index + 10],
vmax_data[index + 9],
vmax_data[index + 8]);
}
for (i = 0; i < step_count; i++)
AW_DEV_LOGI(dev, "vbat_min:%d, vbat_max%d, vmax_vol:0x%x",
vmax_step[i].vbat_min,
vmax_step[i].vbat_max,
vmax_step[i].vmax_vol);
}
static int aw_monitor_parse_vol_data_v1(struct device *dev,
struct aw_monitor *monitor, char *monitor_data)
{
uint32_t step_count = 0;
char *vmax_data = NULL;
struct vmax_step_config *vmax_step = NULL;
AW_DEV_LOGD(dev, "enter");
step_count = monitor->monitor_hdr.step_count;
if (step_count) {
vmax_step = devm_kzalloc(dev, sizeof(struct vmax_step_config) * step_count,
GFP_KERNEL);
if (vmax_step == NULL) {
AW_DEV_LOGE(dev, "vmax_cfg vmalloc failed");
return -ENOMEM;
}
memset(vmax_step, 0,
sizeof(struct vmax_step_config) * step_count);
}
vmax_data = monitor_data + sizeof(struct aw_bin_header) +
sizeof(struct aw_monitor_header);
aw_monitor_write_to_table_v1(dev, vmax_step, vmax_data, step_count);
monitor->vmax_cfg = vmax_step;
AW_DEV_LOGI(dev, "vmax_data parse succeed");
return 0;
}
static int aw_monitor_parse_data_v1(struct device *dev,
struct aw_monitor *monitor, char *monitor_data)
{
int ret = -1;
int header_len = 0;
struct aw_monitor_header *monitor_hdr = &monitor->monitor_hdr;
header_len = sizeof(struct aw_bin_header);
memcpy(monitor_hdr, monitor_data + header_len,
sizeof(struct aw_monitor_header));
AW_DEV_LOGI(dev, "monitor_switch:%d, monitor_time:%d (ms), monitor_count:%d, step_count:%d",
monitor_hdr->monitor_switch, monitor_hdr->monitor_time,
monitor_hdr->monitor_count, monitor_hdr->step_count);
ret = aw_monitor_parse_vol_data_v1(dev, monitor, monitor_data);
if (ret < 0) {
AW_DEV_LOGE(dev, "vmax_data parse failed");
return ret;
}
monitor->bin_status = AW_MONITOR_CFG_OK;
return 0;
}
static int aw_monitor_parse_v_1_0_0(struct device *dev,
struct aw_monitor *monitor, char *monitor_data)
{
int ret = -1;
struct aw_bin_header *header = (struct aw_bin_header *)monitor_data;
switch (header->bin_data_ver) {
case AW_MONITOR_DATA_VER:
ret = aw_monitor_parse_data_v1(dev, monitor, monitor_data);
if (ret < 0)
return ret;
break;
default:
return -EINVAL;
}
return 0;
}
void aw_monitor_cfg_free(struct aw_monitor *monitor)
{
struct aw87xxx *aw87xxx =
container_of(monitor, struct aw87xxx, monitor);
monitor->bin_status = AW_MONITOR_CFG_WAIT;
memset(&monitor->monitor_hdr, 0,
sizeof(struct aw_monitor_header));
if (monitor->vmax_cfg) {
devm_kfree(aw87xxx->dev, monitor->vmax_cfg);
monitor->vmax_cfg = NULL;
}
}
int aw_monitor_bin_parse(struct device *dev,
char *monitor_data, uint32_t data_len)
{
int ret = -1;
struct aw87xxx *aw87xxx = dev_get_drvdata(dev);
struct aw_monitor *monitor = NULL;
struct aw_bin_header *bin_header = NULL;
if (aw87xxx == NULL) {
AW_DEV_LOGE(dev, "get struct aw87xxx failed");
return -EINVAL;
}
monitor = &aw87xxx->monitor;
monitor->bin_status = AW_MONITOR_CFG_WAIT;
AW_DEV_LOGI(dev, "monitor bin parse version: %s",
AW_MONITOT_BIN_PARSE_VERSION);
ret = aw_monitor_bin_check(dev, monitor_data, data_len);
if (ret < 0) {
AW_DEV_LOGE(dev, "monitor bin check failed");
return ret;
}
bin_header = (struct aw_bin_header *)monitor_data;
switch (bin_header->bin_data_ver) {
case DATA_VERSION_V1:
ret = aw_monitor_parse_v_1_0_0(dev, monitor,
monitor_data);
if (ret < 0) {
aw_monitor_cfg_free(monitor);
return ret;
}
break;
default:
AW_DEV_LOGE(dev, "Unrecognized this bin data version[0x%x]",
bin_header->bin_data_ver);
}
return 0;
}
/***************************************************************************
*
* aw87xxx monitor get adjustment vmax of power
*
***************************************************************************/
static int aw_monitor_get_battery_capacity(struct device *dev,
struct aw_monitor *monitor,
uint32_t *vbat_capacity)
{
char name[] = "battery";
int ret = -1;
union power_supply_propval prop = { 0 };
struct power_supply *psy = NULL;
psy = power_supply_get_by_name(name);
if (psy == NULL) {
AW_DEV_LOGE(dev, "no struct power supply name:%s", name);
return -EINVAL;
}
ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_CAPACITY, &prop);
if (ret < 0) {
AW_DEV_LOGE(dev, "get vbat capacity failed");
return -EINVAL;
}
*vbat_capacity = prop.intval;
AW_DEV_LOGI(dev, "The percentage is %d",
*vbat_capacity);
return 0;
}
static int aw_search_vmax_from_table(struct device *dev,
struct aw_monitor *monitor,
const int vbat_vol, int *vmax_vol)
{
int i = 0;
int vmax_set = 0;
uint32_t vmax_flag = 0;
struct aw_monitor_header *monitor_hdr = &monitor->monitor_hdr;
struct vmax_step_config *vmax_cfg = monitor->vmax_cfg;
if (monitor->bin_status == AW_MONITOR_CFG_WAIT) {
AW_DEV_LOGE(dev, "vmax_cfg not loaded or parse failed");
return -ENODATA;
}
for (i = 0; i < monitor_hdr->step_count; i++) {
if (vbat_vol == AW_VBAT_MAX) {
vmax_set = AW_VMAX_MAX;
vmax_flag = 1;
AW_DEV_LOGD(dev, "vbat=%d, setting vmax=0x%x",
vbat_vol, vmax_set);
break;
}
if (vbat_vol >= vmax_cfg[i].vbat_min &&
vbat_vol < vmax_cfg[i].vbat_max) {
vmax_set = vmax_cfg[i].vmax_vol;
vmax_flag = 1;
AW_DEV_LOGD(dev, "read setting vmax=0x%x, step[%d]: vbat_min=%d,vbat_max=%d",
vmax_set, i,
vmax_cfg[i].vbat_min,
vmax_cfg[i].vbat_max);
break;
}
}
if (!vmax_flag) {
AW_DEV_LOGE(dev, "vmax_cfg not found");
return -ENODATA;
}
*vmax_vol = vmax_set;
return 0;
}
/***************************************************************************
*
*monitor_esd_func
*
***************************************************************************/
static int aw_chip_status_recover(struct aw87xxx *aw87xxx)
{
int ret = -1;
struct aw_monitor *monitor = &aw87xxx->monitor;
char *profile = aw87xxx->current_profile;
AW_DEV_LOGD(aw87xxx->dev, "enter");
ret = aw87xxx_esd_update_profile(aw87xxx, profile);
if (ret < 0) {
AW_DEV_LOGE(aw87xxx->dev, "load profile[%s] failed ",
profile);
return ret;
}
AW_DEV_LOGI(aw87xxx->dev, "current prof[%s], dev_index[%d] ",
profile, aw87xxx->dev_index);
monitor->pre_vmax = AW_VMAX_INIT_VAL;
monitor->first_entry = AW_FIRST_ENTRY;
monitor->timer_cnt = 0;
monitor->vbat_sum = 0;
return 0;
}
static int aw_monitor_chip_esd_check_work(struct aw87xxx *aw87xxx)
{
int ret = 0;
int i = 0;
for (i = 0; i < REG_STATUS_CHECK_MAX; i++) {
AW_DEV_LOGD(aw87xxx->dev, "reg_status_check[%d]", i);
ret = aw_dev_esd_reg_status_check(&aw87xxx->aw_dev);
if (ret < 0) {
aw_chip_status_recover(aw87xxx);
} else {
AW_DEV_LOGD(aw87xxx->dev, "chip status check succeed");
break;
}
msleep(AW_ESD_CHECK_DELAY);
}
if (ret < 0) {
AW_DEV_LOGE(aw87xxx->dev, "chip status recover failed,chip off");
aw87xxx_esd_update_profile(aw87xxx, aw87xxx->prof_off_name);
return ret;
}
return 0;
}
/***************************************************************************
*
* aw87xxx monitor work with dsp
*
***************************************************************************/
static int aw_monitor_update_vmax_to_dsp(struct device *dev,
struct aw_monitor *monitor, int vmax_set)
{
int ret = -1;
uint32_t enable = 0;
if (monitor->pre_vmax != vmax_set) {
ret = aw_dsp_get_rx_module_enable(&enable);
if (!enable || ret < 0) {
AW_DEV_LOGE(dev, "get rx failed or rx disable, ret=%d, enable=%d",
ret, enable);
return -EPERM;
}
ret = aw_dsp_set_vmax(vmax_set, monitor->dev_index);
if (ret) {
AW_DEV_LOGE(dev, "set dsp msg fail, ret=%d", ret);
return ret;
}
AW_DEV_LOGI(dev, "set dsp vmax=0x%x sucess", vmax_set);
monitor->pre_vmax = vmax_set;
} else {
AW_DEV_LOGI(dev, "vmax=0x%x no change", vmax_set);
}
return 0;
}
static void aw_monitor_with_dsp_vmax_work(struct device *dev,
struct aw_monitor *monitor)
{
int ret = -1;
int vmax_set = 0;
uint32_t vbat_capacity = 0;
uint32_t ave_capacity = 0;
struct aw_monitor_header *monitor_hdr = &monitor->monitor_hdr;
AW_DEV_LOGD(dev, "enter with dsp monitor");
ret = aw_monitor_get_battery_capacity(dev, monitor, &vbat_capacity);
if (ret < 0)
return;
if (monitor->timer_cnt < monitor_hdr->monitor_count) {
monitor->timer_cnt++;
monitor->vbat_sum += vbat_capacity;
AW_DEV_LOGI(dev, "timer_cnt = %d",
monitor->timer_cnt);
}
if ((monitor->timer_cnt >= monitor_hdr->monitor_count) ||
(monitor->first_entry == AW_FIRST_ENTRY)) {
if (monitor->first_entry == AW_FIRST_ENTRY)
monitor->first_entry = AW_NOT_FIRST_ENTRY;
ave_capacity = monitor->vbat_sum / monitor->timer_cnt;
if (monitor->custom_capacity)
ave_capacity = monitor->custom_capacity;
AW_DEV_LOGI(dev, "get average capacity = %d", ave_capacity);
ret = aw_search_vmax_from_table(dev, monitor,
ave_capacity, &vmax_set);
if (ret < 0)
AW_DEV_LOGE(dev, "not find vmax_vol");
else
aw_monitor_update_vmax_to_dsp(dev, monitor, vmax_set);
monitor->timer_cnt = 0;
monitor->vbat_sum = 0;
}
}
static void aw_monitor_work_func(struct work_struct *work)
{
int ret = 0;
struct aw87xxx *aw87xxx = container_of(work,
struct aw87xxx, monitor.with_dsp_work.work);
struct device *dev = aw87xxx->dev;
struct aw_monitor *monitor = &aw87xxx->monitor;
struct aw_monitor_header *monitor_hdr = &monitor->monitor_hdr;
AW_DEV_LOGD(dev, "enter");
if (monitor->esd_enable) {
ret = aw_monitor_chip_esd_check_work(aw87xxx);
if (ret < 0)
return;
}
if (monitor_hdr->monitor_switch && !(aw87xxx->aw_dev.is_rec_mode) &&
monitor->open_dsp_en && monitor->bin_status == AW_ACF_UPDATE) {
AW_DEV_LOGD(dev, "start low power protection");
aw_monitor_with_dsp_vmax_work(dev, monitor);
}
if (monitor->esd_enable || (monitor_hdr->monitor_switch &&
!(aw87xxx->aw_dev.is_rec_mode) && monitor->open_dsp_en &&
monitor->bin_status == AW_ACF_UPDATE)) {
schedule_delayed_work(&monitor->with_dsp_work,
msecs_to_jiffies(monitor_hdr->monitor_time));
}
}
void aw_monitor_stop(struct aw_monitor *monitor)
{
struct aw87xxx *aw87xxx =
container_of(monitor, struct aw87xxx, monitor);
AW_DEV_LOGD(aw87xxx->dev, "enter");
cancel_delayed_work_sync(&monitor->with_dsp_work);
}
void aw_monitor_start(struct aw_monitor *monitor)
{
struct aw87xxx *aw87xxx =
container_of(monitor, struct aw87xxx, monitor);
int ret = 0;
ret = aw_dev_check_reg_is_rec_mode(&aw87xxx->aw_dev);
if (ret < 0) {
AW_DEV_LOGE(aw87xxx->dev, "get reg current mode failed");
return;
}
if (monitor->esd_enable || (monitor->monitor_hdr.monitor_switch &&
!(aw87xxx->aw_dev.is_rec_mode) && monitor->open_dsp_en
&& monitor->bin_status == AW_ACF_UPDATE)) {
AW_DEV_LOGD(aw87xxx->dev, "enter");
monitor->pre_vmax = AW_VMAX_INIT_VAL;
monitor->first_entry = AW_FIRST_ENTRY;
monitor->timer_cnt = 0;
monitor->vbat_sum = 0;
schedule_delayed_work(&monitor->with_dsp_work,
msecs_to_jiffies(monitor->monitor_hdr.monitor_time));
}
}
/***************************************************************************
*
* aw87xxx no dsp monitor func
*
***************************************************************************/
int aw_monitor_no_dsp_get_vmax(struct aw_monitor *monitor, int32_t *vmax)
{
int vbat_capacity = 0;
int ret = -1;
int vmax_vol = 0;
struct aw87xxx *aw87xxx =
container_of(monitor, struct aw87xxx, monitor);
struct device *dev = aw87xxx->dev;
ret = aw_monitor_get_battery_capacity(dev, monitor, &vbat_capacity);
if (ret < 0)
return ret;
if (monitor->custom_capacity)
vbat_capacity = monitor->custom_capacity;
AW_DEV_LOGI(dev, "get_battery_capacity is[%d]", vbat_capacity);
ret = aw_search_vmax_from_table(dev, monitor,
vbat_capacity, &vmax_vol);
if (ret < 0) {
AW_DEV_LOGE(dev, "not find vmax_vol");
return ret;
}
*vmax = vmax_vol;
return 0;
}
/***************************************************************************
*
* aw87xxx monitor sysfs nodes
*
***************************************************************************/
static ssize_t aw_attr_get_esd_enable(struct device *dev,
struct device_attribute *attr, char *buf)
{
ssize_t len = 0;
struct aw87xxx *aw87xxx = dev_get_drvdata(dev);
struct aw_monitor *monitor = &aw87xxx->monitor;
if (monitor->esd_enable) {
AW_DEV_LOGI(aw87xxx->dev, "esd-enable=true");
len += snprintf(buf + len, PAGE_SIZE - len,
"esd-enable=true\n");
} else {
AW_DEV_LOGI(aw87xxx->dev, "esd-enable=false");
len += snprintf(buf + len, PAGE_SIZE - len,
"esd-enable=false\n");
}
return len;
}
static ssize_t aw_attr_set_esd_enable(struct device *dev,
struct device_attribute *attr, const char *buf, size_t len)
{
char esd_enable[16] = {0};
struct aw87xxx *aw87xxx = dev_get_drvdata(dev);
struct aw_monitor *monitor = &aw87xxx->monitor;
if (sscanf(buf, "%s", esd_enable) == 1) {
AW_DEV_LOGD(aw87xxx->dev, "input esd-enable=[%s]", esd_enable);
if (!strcmp(esd_enable, "true"))
monitor->esd_enable = AW_ESD_ENABLE;
else
monitor->esd_enable = AW_ESD_DISABLE;
AW_DEV_LOGI(dev, "set esd-enable=[%s]",
monitor->esd_enable ? "true" : "false");
} else {
AW_DEV_LOGE(aw87xxx->dev, "input esd-enable error");
return -EINVAL;
}
return len;
}
static ssize_t aw_attr_get_vbat(struct device *dev,
struct device_attribute *attr, char *buf)
{
ssize_t len = 0;
int ret = -1;
int vbat_capacity = 0;
struct aw87xxx *aw87xxx = dev_get_drvdata(dev);
struct aw_monitor *monitor = &aw87xxx->monitor;
if (monitor->custom_capacity == 0) {
ret = aw_monitor_get_battery_capacity(dev, monitor,
&vbat_capacity);
if (ret < 0) {
AW_DEV_LOGE(aw87xxx->dev, "get battery_capacity failed");
return ret;
}
len += snprintf(buf + len, PAGE_SIZE - len,
"vbat capacity=%d\n", vbat_capacity);
} else {
len += snprintf(buf + len, PAGE_SIZE - len,
"vbat capacity=%d\n",
monitor->custom_capacity);
}
return len;
}
static ssize_t aw_attr_set_vbat(struct device *dev,
struct device_attribute *attr, const char *buf, size_t len)
{
int ret = -1;
uint32_t capacity = 0;
struct aw87xxx *aw87xxx = dev_get_drvdata(dev);
struct aw_monitor *monitor = &aw87xxx->monitor;
ret = kstrtouint(buf, 0, &capacity);
if (ret < 0)
return ret;
AW_DEV_LOGI(aw87xxx->dev, "set capacity = %d", capacity);
if (capacity >= AW_VBAT_CAPACITY_MIN &&
capacity <= AW_VBAT_CAPACITY_MAX){
monitor->custom_capacity = capacity;
} else {
AW_DEV_LOGE(aw87xxx->dev, "vbat_set=invalid,please input value [%d-%d]",
AW_VBAT_CAPACITY_MIN, AW_VBAT_CAPACITY_MAX);
return -EINVAL;
}
return len;
}
static ssize_t aw_attr_get_vmax(struct device *dev,
struct device_attribute *attr, char *buf)
{
ssize_t len = 0;
int ret = -1;
uint32_t vbat_capacity = 0;
int vmax_get = 0;
struct aw87xxx *aw87xxx = dev_get_drvdata(dev);
struct aw_monitor *monitor = &aw87xxx->monitor;
if (monitor->open_dsp_en) {
ret = aw_dsp_get_vmax(&vmax_get, aw87xxx->dev_index);
if (ret < 0) {
AW_DEV_LOGE(aw87xxx->dev,
"get dsp vmax fail, ret=%d", ret);
return ret;
}
len += snprintf(buf + len, PAGE_SIZE - len,
"get_vmax=0x%x\n", vmax_get);
} else {
ret = aw_monitor_get_battery_capacity(dev, monitor,
&vbat_capacity);
if (ret < 0)
return ret;
AW_DEV_LOGI(aw87xxx->dev, "get_battery_capacity is [%d]",
vbat_capacity);
if (monitor->custom_capacity) {
vbat_capacity = monitor->custom_capacity;
AW_DEV_LOGI(aw87xxx->dev, "get custom_capacity is [%d]",
vbat_capacity);
}
ret = aw_search_vmax_from_table(aw87xxx->dev, monitor,
vbat_capacity, &vmax_get);
if (ret < 0) {
AW_DEV_LOGE(aw87xxx->dev, "not find vmax_vol");
len += snprintf(buf + len, PAGE_SIZE - len,
"not_find_vmax_vol\n");
return len;
}
len += snprintf(buf + len, PAGE_SIZE - len,
"0x%x\n", vmax_get);
AW_DEV_LOGI(aw87xxx->dev, "0x%x", vmax_get);
}
return len;
}
static ssize_t aw_attr_set_vmax(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
uint32_t vmax_set = 0;
int ret = -1;
struct aw87xxx *aw87xxx = dev_get_drvdata(dev);
struct aw_monitor *monitor = &aw87xxx->monitor;
ret = kstrtouint(buf, 0, &vmax_set);
if (ret < 0)
return ret;
AW_DEV_LOGI(aw87xxx->dev, "vmax_set=0x%x", vmax_set);
if (monitor->open_dsp_en) {
ret = aw_dsp_set_vmax(vmax_set, aw87xxx->dev_index);
if (ret < 0) {
AW_DEV_LOGE(aw87xxx->dev, "send dsp_msg error, ret = %d",
ret);
return ret;
}
msleep(2);
} else {
AW_DEV_LOGE(aw87xxx->dev, "no_dsp system,vmax_set invalid");
return -EINVAL;
}
return count;
}
static ssize_t aw_attr_get_monitor_switch(struct device *dev,
struct device_attribute *attr, char *buf)
{
ssize_t len = 0;
struct aw87xxx *aw87xxx = dev_get_drvdata(dev);
struct aw_monitor *monitor = &aw87xxx->monitor;
struct aw_monitor_header *monitor_hdr = &monitor->monitor_hdr;
len += snprintf(buf + len, PAGE_SIZE - len,
"aw87xxx monitor switch: %d\n",
monitor_hdr->monitor_switch);
return len;
}
static ssize_t aw_attr_set_monitor_switch(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
uint32_t enable = 0;
int ret = -1;
struct aw87xxx *aw87xxx = dev_get_drvdata(dev);
struct aw_monitor *monitor = &aw87xxx->monitor;
struct aw_monitor_header *monitor_hdr = &monitor->monitor_hdr;
ret = kstrtouint(buf, 0, &enable);
if (ret < 0)
return ret;
AW_DEV_LOGI(aw87xxx->dev, "monitor switch set =%d", enable);
if (!monitor->bin_status) {
AW_DEV_LOGE(aw87xxx->dev, "bin parse faile or not loaded,set invalid");
return -EINVAL;
}
if (enable > 0)
monitor_hdr->monitor_switch = 1;
else
monitor_hdr->monitor_switch = 0;
if (monitor->open_dsp_en && enable) {
monitor_hdr->monitor_switch = 1;
monitor->pre_vmax = AW_VMAX_INIT_VAL;
monitor->first_entry = AW_FIRST_ENTRY;
monitor->timer_cnt = 0;
monitor->vbat_sum = 0;
} else if (monitor->open_dsp_en && !enable) {
monitor_hdr->monitor_switch = 0;
}
return count;
}
static ssize_t aw_attr_get_monitor_time(struct device *dev,
struct device_attribute *attr, char *buf)
{
ssize_t len = 0;
struct aw87xxx *aw87xxx = dev_get_drvdata(dev);
struct aw_monitor *monitor = &aw87xxx->monitor;
struct aw_monitor_header *monitor_hdr = &monitor->monitor_hdr;
len += snprintf(buf + len, PAGE_SIZE - len,
"aw_monitor_timer = %d(ms)\n",
monitor_hdr->monitor_time);
return len;
}
static ssize_t aw_attr_set_monitor_time(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
unsigned int timer_val = 0;
int ret = -1;
struct aw87xxx *aw87xxx = dev_get_drvdata(dev);
struct aw_monitor *monitor = &aw87xxx->monitor;
struct aw_monitor_header *monitor_hdr = &monitor->monitor_hdr;
ret = kstrtouint(buf, 0, &timer_val);
if (ret < 0)
return ret;
AW_DEV_LOGI(aw87xxx->dev, "input monitor timer=%d(ms)", timer_val);
if (!monitor->bin_status) {
AW_DEV_LOGE(aw87xxx->dev, "bin parse faile or not loaded,set invalid");
return -EINVAL;
}
if (timer_val != monitor_hdr->monitor_time)
monitor_hdr->monitor_time = timer_val;
else
AW_DEV_LOGI(aw87xxx->dev, "no_change monitor_time");
return count;
}
static ssize_t aw_attr_get_monitor_count(struct device *dev,
struct device_attribute *attr, char *buf)
{
ssize_t len = 0;
struct aw87xxx *aw87xxx = dev_get_drvdata(dev);
struct aw_monitor *monitor = &aw87xxx->monitor;
struct aw_monitor_header *monitor_hdr = &monitor->monitor_hdr;
len += snprintf(buf + len, PAGE_SIZE - len,
"aw_monitor_count = %d\n",
monitor_hdr->monitor_count);
return len;
}
static ssize_t aw_attr_set_monitor_count(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
unsigned int monitor_count = 0;
int ret = -1;
struct aw87xxx *aw87xxx = dev_get_drvdata(dev);
struct aw_monitor *monitor = &aw87xxx->monitor;
struct aw_monitor_header *monitor_hdr = &monitor->monitor_hdr;
ret = kstrtouint(buf, 0, &monitor_count);
if (ret < 0)
return ret;
AW_DEV_LOGI(aw87xxx->dev, "input monitor count=%d", monitor_count);
if (!monitor->bin_status) {
AW_DEV_LOGE(aw87xxx->dev, "bin parse faile or not loaded,set invalid");
return -EINVAL;
}
if (monitor_count != monitor_hdr->monitor_count)
monitor_hdr->monitor_count = monitor_count;
else
AW_DEV_LOGI(aw87xxx->dev, "no_change monitor_count");
return count;
}
static ssize_t aw_attr_get_rx(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct aw87xxx *aw87xxx = dev_get_drvdata(dev);
struct aw_monitor *monitor = &aw87xxx->monitor;
ssize_t len = 0;
int ret = -1;
uint32_t enable = 0;
if (monitor->open_dsp_en) {
ret = aw_dsp_get_rx_module_enable(&enable);
if (ret) {
AW_DEV_LOGE(aw87xxx->dev, "dsp_msg error, ret=%d", ret);
return ret;
}
len += snprintf(buf + len, PAGE_SIZE - len,
"aw87xxx rx: %d\n", enable);
} else {
len += snprintf(buf + len, PAGE_SIZE - len,
"command is invalid\n");
}
return len;
}
static ssize_t aw_attr_set_rx(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct aw87xxx *aw87xxx = dev_get_drvdata(dev);
struct aw_monitor *monitor = &aw87xxx->monitor;
int ret = -1;
uint32_t enable;
ret = kstrtouint(buf, 0, &enable);
if (ret < 0)
return ret;
if (monitor->open_dsp_en) {
AW_DEV_LOGI(aw87xxx->dev, "set rx enable=%d", enable);
ret = aw_dsp_set_rx_module_enable(enable);
if (ret < 0) {
AW_DEV_LOGE(aw87xxx->dev, "dsp_msg error, ret=%d",
ret);
return ret;
}
} else {
AW_DEV_LOGE(aw87xxx->dev, "command is invalid");
return -EINVAL;
}
return count;
}
static DEVICE_ATTR(esd_enable, S_IWUSR | S_IRUGO,
aw_attr_get_esd_enable, aw_attr_set_esd_enable);
static DEVICE_ATTR(vbat, S_IWUSR | S_IRUGO,
aw_attr_get_vbat, aw_attr_set_vbat);
static DEVICE_ATTR(vmax, S_IWUSR | S_IRUGO,
aw_attr_get_vmax, aw_attr_set_vmax);
static DEVICE_ATTR(monitor_switch, S_IWUSR | S_IRUGO,
aw_attr_get_monitor_switch, aw_attr_set_monitor_switch);
static DEVICE_ATTR(monitor_time, S_IWUSR | S_IRUGO,
aw_attr_get_monitor_time, aw_attr_set_monitor_time);
static DEVICE_ATTR(monitor_count, S_IWUSR | S_IRUGO,
aw_attr_get_monitor_count, aw_attr_set_monitor_count);
static DEVICE_ATTR(rx, S_IWUSR | S_IRUGO,
aw_attr_get_rx, aw_attr_set_rx);
static struct attribute *aw_monitor_vol_adjust[] = {
&dev_attr_esd_enable.attr,
&dev_attr_vbat.attr,
&dev_attr_vmax.attr,
NULL
};
static struct attribute_group aw_monitor_vol_adjust_group = {
.attrs = aw_monitor_vol_adjust,
};
static struct attribute *aw_monitor_control[] = {
&dev_attr_monitor_switch.attr,
&dev_attr_monitor_time.attr,
&dev_attr_monitor_count.attr,
&dev_attr_rx.attr,
NULL
};
static struct attribute_group aw_monitor_control_group = {
.attrs = aw_monitor_control,
};
/***************************************************************************
*
* aw87xxx monitor init
*
***************************************************************************/
static void aw_monitor_dtsi_parse(struct device *dev,
struct aw_monitor *monitor,
struct device_node *dev_node)
{
int ret = -1;
const char *esd_enable;
ret = of_property_read_string(dev_node, "esd-enable", &esd_enable);
if (ret < 0) {
AW_DEV_LOGI(dev, "esd_enable parse failed, user default[disable]");
monitor->esd_enable = AW_ESD_DISABLE;
} else {
if (!strcmp(esd_enable, "true"))
monitor->esd_enable = AW_ESD_ENABLE;
else
monitor->esd_enable = AW_ESD_DISABLE;
AW_DEV_LOGI(dev, "parse esd-enable=[%s]",
monitor->esd_enable ? "true" : "false");
}
}
void aw_monitor_init(struct device *dev, struct aw_monitor *monitor,
struct device_node *dev_node)
{
int ret = -1;
struct aw87xxx *aw87xxx =
container_of(monitor, struct aw87xxx, monitor);
monitor->dev_index = aw87xxx->dev_index;
monitor->monitor_hdr.monitor_time = AW_DEFAULT_MONITOR_TIME;
aw_monitor_dtsi_parse(dev, monitor, dev_node);
/* get platform open dsp type */
monitor->open_dsp_en = aw_dsp_isEnable();
ret = sysfs_create_group(&dev->kobj, &aw_monitor_vol_adjust_group);
if (ret < 0)
AW_DEV_LOGE(dev, "failed to create monitor vol_adjust sysfs nodes");
INIT_DELAYED_WORK(&monitor->with_dsp_work, aw_monitor_work_func);
if (monitor->open_dsp_en) {
ret = sysfs_create_group(&dev->kobj, &aw_monitor_control_group);
if (ret < 0)
AW_DEV_LOGE(dev, "failed to create monitor dsp control sysfs nodes");
}
if (!ret)
AW_DEV_LOGI(dev, "monitor init succeed");
}
void aw_monitor_exit(struct aw_monitor *monitor)
{
struct aw87xxx *aw87xxx =
container_of(monitor, struct aw87xxx, monitor);
/*rm attr node*/
sysfs_remove_group(&aw87xxx->dev->kobj,
&aw_monitor_vol_adjust_group);
aw_monitor_stop(monitor);
if (monitor->open_dsp_en) {
sysfs_remove_group(&aw87xxx->dev->kobj,
&aw_monitor_control_group);
}
}
Reference in New Issue View Git Blame Copy Permalink