You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
425 lines
12 KiB
425 lines
12 KiB
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Copyright (c) 2019, The Linux Foundation. All rights reserved.
|
|
*/
|
|
|
|
#include <dsp/q6audio-v2.h>
|
|
#include <dsp/q6afe-v2.h>
|
|
#include <linux/msm_audio_calibration.h>
|
|
#include <dsp/sp_params.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/device.h>
|
|
|
|
/* export or show spk params at /sys/class/spk_params/cal_data */
|
|
#define SPK_PARAMS "spk_params"
|
|
#define CLASS_NAME "cal_data"
|
|
#define BUF_SZ 20
|
|
#define Q22 (1<<22)
|
|
#define Q13 (1<<13)
|
|
#define Q7 (1<<7)
|
|
|
|
struct afe_spk_ctl {
|
|
struct class *p_class;
|
|
struct device *p_dev;
|
|
struct afe_sp_rx_tmax_xmax_logging_param xt_logging;
|
|
int32_t max_temperature_rd[SP_V2_NUM_MAX_SPKR];
|
|
};
|
|
struct afe_spk_ctl this_afe_spk;
|
|
|
|
static ssize_t sp_count_exceeded_temperature_l_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
ssize_t ret = 0;
|
|
|
|
ret = snprintf(buf, BUF_SZ, "%d\n",
|
|
this_afe_spk.xt_logging.count_exceeded_temperature[SP_V2_SPKR_1]);
|
|
this_afe_spk.xt_logging.count_exceeded_temperature[SP_V2_SPKR_1] = 0;
|
|
return ret;
|
|
}
|
|
static DEVICE_ATTR(count_exceeded_temperature, 0644,
|
|
sp_count_exceeded_temperature_l_show, NULL);
|
|
|
|
static ssize_t sp_count_exceeded_temperature_r_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
ssize_t ret = 0;
|
|
|
|
ret = snprintf(buf, BUF_SZ, "%d\n",
|
|
this_afe_spk.xt_logging.count_exceeded_temperature[SP_V2_SPKR_2]);
|
|
this_afe_spk.xt_logging.count_exceeded_temperature[SP_V2_SPKR_2] = 0;
|
|
return ret;
|
|
}
|
|
static DEVICE_ATTR(count_exceeded_temperature_r, 0644,
|
|
sp_count_exceeded_temperature_r_show, NULL);
|
|
|
|
static ssize_t sp_count_exceeded_excursion_l_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
ssize_t ret = 0;
|
|
|
|
ret = snprintf(buf, BUF_SZ, "%d\n",
|
|
this_afe_spk.xt_logging.count_exceeded_excursion[SP_V2_SPKR_1]);
|
|
this_afe_spk.xt_logging.count_exceeded_excursion[SP_V2_SPKR_1] = 0;
|
|
return ret;
|
|
}
|
|
static DEVICE_ATTR(count_exceeded_excursion, 0644,
|
|
sp_count_exceeded_excursion_l_show, NULL);
|
|
|
|
static ssize_t sp_count_exceeded_excursion_r_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
ssize_t ret = 0;
|
|
|
|
ret = snprintf(buf, BUF_SZ, "%d\n",
|
|
this_afe_spk.xt_logging.count_exceeded_excursion[SP_V2_SPKR_2]);
|
|
this_afe_spk.xt_logging.count_exceeded_excursion[SP_V2_SPKR_2] = 0;
|
|
return ret;
|
|
}
|
|
static DEVICE_ATTR(count_exceeded_excursion_r, 0644,
|
|
sp_count_exceeded_excursion_r_show, NULL);
|
|
|
|
static ssize_t sp_max_excursion_l_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
ssize_t ret = 0;
|
|
int32_t ex_val_frac;
|
|
int32_t ex_q27 = this_afe_spk.xt_logging.max_excursion[SP_V2_SPKR_1];
|
|
|
|
ex_val_frac = ex_q27/Q13;
|
|
ex_val_frac = (ex_val_frac * 10000)/(Q7 * Q7);
|
|
ex_val_frac /= 100;
|
|
ret = snprintf(buf, BUF_SZ, "%d.%02d\n", 0, ex_val_frac);
|
|
this_afe_spk.xt_logging.max_excursion[SP_V2_SPKR_1] = 0;
|
|
return ret;
|
|
}
|
|
static DEVICE_ATTR(max_excursion, 0644, sp_max_excursion_l_show, NULL);
|
|
|
|
static ssize_t sp_max_excursion_r_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
ssize_t ret = 0;
|
|
int32_t ex_val_frac;
|
|
int32_t ex_q27 = this_afe_spk.xt_logging.max_excursion[SP_V2_SPKR_2];
|
|
|
|
ex_val_frac = ex_q27/Q13;
|
|
ex_val_frac = (ex_val_frac * 10000)/(Q7 * Q7);
|
|
ex_val_frac /= 100;
|
|
ret = snprintf(buf, BUF_SZ, "%d.%02d\n", 0, ex_val_frac);
|
|
this_afe_spk.xt_logging.max_excursion[SP_V2_SPKR_2] = 0;
|
|
return ret;
|
|
}
|
|
static DEVICE_ATTR(max_excursion_r, 0644, sp_max_excursion_r_show, NULL);
|
|
|
|
static ssize_t sp_max_temperature_l_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
ssize_t ret = 0;
|
|
|
|
ret = snprintf(buf, BUF_SZ, "%d\n",
|
|
this_afe_spk.xt_logging.max_temperature[SP_V2_SPKR_1]/Q22);
|
|
this_afe_spk.xt_logging.max_temperature[SP_V2_SPKR_1] = 0;
|
|
return ret;
|
|
}
|
|
static DEVICE_ATTR(max_temperature, 0644, sp_max_temperature_l_show, NULL);
|
|
|
|
static ssize_t sp_max_temperature_r_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
ssize_t ret = 0;
|
|
|
|
ret = snprintf(buf, BUF_SZ, "%d\n",
|
|
this_afe_spk.xt_logging.max_temperature[SP_V2_SPKR_2]/Q22);
|
|
this_afe_spk.xt_logging.max_temperature[SP_V2_SPKR_2] = 0;
|
|
return ret;
|
|
}
|
|
static DEVICE_ATTR(max_temperature_r, 0644, sp_max_temperature_r_show, NULL);
|
|
|
|
static ssize_t sp_max_temperature_rd_l_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
return snprintf(buf, BUF_SZ, "%d\n",
|
|
this_afe_spk.max_temperature_rd[SP_V2_SPKR_1]/Q22);
|
|
}
|
|
static DEVICE_ATTR(max_temperature_rd, 0644,
|
|
sp_max_temperature_rd_l_show, NULL);
|
|
|
|
static ssize_t sp_max_temperature_rd_r_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
return snprintf(buf, BUF_SZ, "%d\n",
|
|
this_afe_spk.max_temperature_rd[SP_V2_SPKR_2]/Q22);
|
|
}
|
|
static DEVICE_ATTR(max_temperature_rd_r, 0644,
|
|
sp_max_temperature_rd_r_show, NULL);
|
|
|
|
static ssize_t q6afe_initial_cal_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
return snprintf(buf, BUF_SZ, "%d\n", afe_get_spk_initial_cal());
|
|
}
|
|
|
|
static ssize_t q6afe_initial_cal_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t size)
|
|
{
|
|
int initial_cal = 0;
|
|
|
|
if (!kstrtou32(buf, 0, &initial_cal)) {
|
|
initial_cal = initial_cal > 0 ? 1 : 0;
|
|
if (initial_cal == afe_get_spk_initial_cal())
|
|
dev_dbg(dev, "%s: same value already present\n",
|
|
__func__);
|
|
else
|
|
afe_set_spk_initial_cal(initial_cal);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
static DEVICE_ATTR(initial_cal, 0644,
|
|
q6afe_initial_cal_show, q6afe_initial_cal_store);
|
|
|
|
static ssize_t q6afe_v_vali_flag_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
return snprintf(buf, BUF_SZ, "%d\n", afe_get_spk_v_vali_flag());
|
|
}
|
|
|
|
static ssize_t q6afe_v_vali_flag_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t size)
|
|
{
|
|
int v_vali_flag = 0;
|
|
|
|
if (!kstrtou32(buf, 0, &v_vali_flag)) {
|
|
v_vali_flag = v_vali_flag > 0 ? 1 : 0;
|
|
if (v_vali_flag == afe_get_spk_v_vali_flag())
|
|
dev_dbg(dev, "%s: same value already present\n",
|
|
__func__);
|
|
else
|
|
afe_set_spk_v_vali_flag(v_vali_flag);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
static DEVICE_ATTR(v_vali_flag, 0644,
|
|
q6afe_v_vali_flag_show, q6afe_v_vali_flag_store);
|
|
|
|
static ssize_t q6afe_spk_r0_l_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
int r0[SP_V2_NUM_MAX_SPKRS];
|
|
|
|
afe_get_spk_r0(r0);
|
|
return snprintf(buf, BUF_SZ, "%d\n", r0[SP_V2_SPKR_1]);
|
|
}
|
|
|
|
static DEVICE_ATTR(spk_r0, 0644, q6afe_spk_r0_l_show, NULL);
|
|
|
|
static ssize_t q6afe_spk_t0_l_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
int t0[SP_V2_NUM_MAX_SPKRS];
|
|
|
|
afe_get_spk_t0(t0);
|
|
return snprintf(buf, BUF_SZ, "%d\n", t0[SP_V2_SPKR_1]);
|
|
}
|
|
|
|
static DEVICE_ATTR(spk_t0, 0644, q6afe_spk_t0_l_show, NULL);
|
|
|
|
static ssize_t q6afe_spk_r0_r_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
int r0[SP_V2_NUM_MAX_SPKRS];
|
|
|
|
afe_get_spk_r0(r0);
|
|
return snprintf(buf, BUF_SZ, "%d\n", r0[SP_V2_SPKR_2]);
|
|
}
|
|
|
|
static DEVICE_ATTR(spk_r0_r, 0644, q6afe_spk_r0_r_show, NULL);
|
|
|
|
static ssize_t q6afe_spk_t0_r_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
int t0[SP_V2_NUM_MAX_SPKRS];
|
|
|
|
afe_get_spk_t0(t0);
|
|
return snprintf(buf, BUF_SZ, "%d\n", t0[SP_V2_SPKR_2]);
|
|
}
|
|
|
|
static DEVICE_ATTR(spk_t0_r, 0644, q6afe_spk_t0_r_show, NULL);
|
|
|
|
static ssize_t q6afe_spk_v_vali_l_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
int v_vali_sts[SP_V2_NUM_MAX_SPKRS];
|
|
|
|
afe_get_spk_v_vali_sts(v_vali_sts);
|
|
return snprintf(buf, BUF_SZ, "%d\n", v_vali_sts[SP_V2_SPKR_1]);
|
|
}
|
|
|
|
static DEVICE_ATTR(spk_v_vali_status, 0644, q6afe_spk_v_vali_l_show, NULL);
|
|
|
|
static ssize_t q6afe_spk_v_vali_r_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
int v_vali_sts[SP_V2_NUM_MAX_SPKRS];
|
|
|
|
afe_get_spk_v_vali_sts(v_vali_sts);
|
|
return snprintf(buf, BUF_SZ, "%d\n", v_vali_sts[SP_V2_SPKR_2]);
|
|
}
|
|
|
|
static DEVICE_ATTR(spk_v_vali_r_status, 0644, q6afe_spk_v_vali_r_show, NULL);
|
|
|
|
static struct attribute *afe_spk_cal_attr[] = {
|
|
&dev_attr_max_excursion.attr,
|
|
&dev_attr_max_excursion_r.attr,
|
|
&dev_attr_max_temperature.attr,
|
|
&dev_attr_max_temperature_r.attr,
|
|
&dev_attr_count_exceeded_excursion.attr,
|
|
&dev_attr_count_exceeded_excursion_r.attr,
|
|
&dev_attr_count_exceeded_temperature.attr,
|
|
&dev_attr_count_exceeded_temperature_r.attr,
|
|
&dev_attr_max_temperature_rd.attr,
|
|
&dev_attr_max_temperature_rd_r.attr,
|
|
&dev_attr_initial_cal.attr,
|
|
&dev_attr_spk_r0.attr,
|
|
&dev_attr_spk_t0.attr,
|
|
&dev_attr_spk_r0_r.attr,
|
|
&dev_attr_spk_t0_r.attr,
|
|
&dev_attr_v_vali_flag.attr,
|
|
&dev_attr_spk_v_vali_status.attr,
|
|
&dev_attr_spk_v_vali_r_status.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group afe_spk_cal_attr_grp = {
|
|
.attrs = afe_spk_cal_attr,
|
|
};
|
|
|
|
|
|
/**
|
|
* afe_get_sp_xt_logging_data -
|
|
* to get excursion logging data from DSP
|
|
*
|
|
* @port: AFE port ID
|
|
*
|
|
* Returns 0 on success or error on failure
|
|
*/
|
|
int afe_get_sp_xt_logging_data(u16 port_id)
|
|
{
|
|
int ret = 0;
|
|
struct afe_sp_rx_tmax_xmax_logging_param xt_logging_data;
|
|
|
|
ret = afe_get_sp_rx_tmax_xmax_logging_data(&xt_logging_data, port_id);
|
|
if (ret) {
|
|
pr_err("%s Excursion logging fail\n", __func__);
|
|
return ret;
|
|
}
|
|
/* storing max sp param value */
|
|
if (this_afe_spk.xt_logging.max_temperature[SP_V2_SPKR_1] <
|
|
xt_logging_data.max_temperature[SP_V2_SPKR_1])
|
|
this_afe_spk.xt_logging.max_temperature[SP_V2_SPKR_1] =
|
|
xt_logging_data.max_temperature[SP_V2_SPKR_1];
|
|
|
|
|
|
if (this_afe_spk.xt_logging.max_temperature[SP_V2_SPKR_2] <
|
|
xt_logging_data.max_temperature[SP_V2_SPKR_2])
|
|
this_afe_spk.xt_logging.max_temperature[SP_V2_SPKR_2] =
|
|
xt_logging_data.max_temperature[SP_V2_SPKR_2];
|
|
|
|
|
|
/* update temp for max_temperature_rd node */
|
|
if (this_afe_spk.max_temperature_rd[SP_V2_SPKR_1] <
|
|
xt_logging_data.max_temperature[SP_V2_SPKR_1])
|
|
this_afe_spk.max_temperature_rd[SP_V2_SPKR_1] =
|
|
xt_logging_data.max_temperature[SP_V2_SPKR_1];
|
|
|
|
if (this_afe_spk.max_temperature_rd[SP_V2_SPKR_2] <
|
|
xt_logging_data.max_temperature[SP_V2_SPKR_2])
|
|
this_afe_spk.max_temperature_rd[SP_V2_SPKR_2] =
|
|
xt_logging_data.max_temperature[SP_V2_SPKR_2];
|
|
|
|
|
|
if (this_afe_spk.xt_logging.max_excursion[SP_V2_SPKR_1] <
|
|
xt_logging_data.max_excursion[SP_V2_SPKR_1])
|
|
this_afe_spk.xt_logging.max_excursion[SP_V2_SPKR_1] =
|
|
xt_logging_data.max_excursion[SP_V2_SPKR_1];
|
|
|
|
if (this_afe_spk.xt_logging.max_excursion[SP_V2_SPKR_2] <
|
|
xt_logging_data.max_excursion[SP_V2_SPKR_2])
|
|
this_afe_spk.xt_logging.max_excursion[SP_V2_SPKR_2] =
|
|
xt_logging_data.max_excursion[SP_V2_SPKR_2];
|
|
|
|
if (this_afe_spk.xt_logging.count_exceeded_temperature[SP_V2_SPKR_1] <
|
|
xt_logging_data.count_exceeded_temperature[SP_V2_SPKR_1])
|
|
this_afe_spk.xt_logging.count_exceeded_temperature[SP_V2_SPKR_1]
|
|
+= xt_logging_data.count_exceeded_temperature[SP_V2_SPKR_1];
|
|
|
|
if (this_afe_spk.xt_logging.count_exceeded_temperature[SP_V2_SPKR_2] <
|
|
xt_logging_data.count_exceeded_temperature[SP_V2_SPKR_2])
|
|
this_afe_spk.xt_logging.count_exceeded_temperature[SP_V2_SPKR_2]
|
|
+= xt_logging_data.count_exceeded_temperature[SP_V2_SPKR_2];
|
|
|
|
if (this_afe_spk.xt_logging.count_exceeded_excursion[SP_V2_SPKR_1] <
|
|
xt_logging_data.count_exceeded_excursion[SP_V2_SPKR_1])
|
|
this_afe_spk.xt_logging.count_exceeded_excursion[SP_V2_SPKR_1]
|
|
+= xt_logging_data.count_exceeded_excursion[SP_V2_SPKR_1];
|
|
|
|
if (this_afe_spk.xt_logging.count_exceeded_excursion[SP_V2_SPKR_2] <
|
|
xt_logging_data.count_exceeded_excursion[SP_V2_SPKR_2])
|
|
this_afe_spk.xt_logging.count_exceeded_excursion[SP_V2_SPKR_2]
|
|
+= xt_logging_data.count_exceeded_excursion[SP_V2_SPKR_2];
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(afe_get_sp_xt_logging_data);
|
|
|
|
int __init spk_params_init(void)
|
|
{
|
|
/* initialize xt param value with 0 */
|
|
this_afe_spk.xt_logging.max_temperature[SP_V2_SPKR_1] = 0;
|
|
this_afe_spk.xt_logging.max_temperature[SP_V2_SPKR_2] = 0;
|
|
this_afe_spk.xt_logging.max_excursion[SP_V2_SPKR_1] = 0;
|
|
this_afe_spk.xt_logging.max_excursion[SP_V2_SPKR_2] = 0;
|
|
this_afe_spk.xt_logging.count_exceeded_temperature[SP_V2_SPKR_1] = 0;
|
|
this_afe_spk.xt_logging.count_exceeded_temperature[SP_V2_SPKR_2] = 0;
|
|
this_afe_spk.xt_logging.count_exceeded_excursion[SP_V2_SPKR_1] = 0;
|
|
this_afe_spk.xt_logging.count_exceeded_excursion[SP_V2_SPKR_2] = 0;
|
|
|
|
this_afe_spk.p_class = class_create(THIS_MODULE, SPK_PARAMS);
|
|
if (this_afe_spk.p_class) {
|
|
this_afe_spk.p_dev = device_create(this_afe_spk.p_class, NULL,
|
|
1, NULL, CLASS_NAME);
|
|
if (!IS_ERR(this_afe_spk.p_dev)) {
|
|
if (sysfs_create_group(&this_afe_spk.p_dev->kobj,
|
|
&afe_spk_cal_attr_grp))
|
|
pr_err("%s: Failed to create sysfs group\n",
|
|
__func__);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void spk_params_exit(void)
|
|
{
|
|
pr_debug("%s\n", __func__);
|
|
}
|
|
|