420 lines
10 KiB
C
420 lines
10 KiB
C
|
/*
|
||
|
|
* Extended support for Cirrus Logic Smart Amplifiers
|
||
|
|
*
|
||
|
|
* Copyright 2017 Cirrus Logic
|
||
|
|
*
|
||
|
|
* Author: David Rhodes <david.rhodes@cirrus.com>
|
||
|
|
*
|
||
|
|
* This program is free software; you can redistribute it and/or modify
|
||
|
|
* it under the terms of the GNU General Public License version 2 as
|
||
|
|
* published by the Free Software Foundation.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <linux/device.h>
|
||
|
|
#include <linux/module.h>
|
||
|
|
#include <linux/of.h>
|
||
|
|
#include <linux/platform_device.h>
|
||
|
|
#include <linux/slab.h>
|
||
|
|
#include <sound/cirrus/core.h>
|
||
|
|
#include <sound/cirrus/big_data.h>
|
||
|
|
#include <sound/cirrus/calibration.h>
|
||
|
|
#include <sound/cirrus/power.h>
|
||
|
|
|
||
|
|
#include "wmfw.h"
|
||
|
|
#include "wm_adsp.h"
|
||
|
|
|
||
|
|
struct class *cirrus_amp_class;
|
||
|
|
EXPORT_SYMBOL_GPL(cirrus_amp_class);
|
||
|
|
|
||
|
|
struct cirrus_amp_group *amp_group;
|
||
|
|
|
||
|
|
static struct cirrus_cal_ops *cirrus_cal_ops[3] = {
|
||
|
|
&cirrus_cspl_cal_ops,
|
||
|
|
&cirrus_cspl_cal_ops,
|
||
|
|
&cirrus_cs35l43_cal_ops
|
||
|
|
};
|
||
|
|
|
||
|
|
struct cirrus_amp *cirrus_get_amp_from_suffix(const char *suffix)
|
||
|
|
{
|
||
|
|
int i;
|
||
|
|
|
||
|
|
if (amp_group == NULL || (amp_group->num_amps == 0))
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
pr_debug("%s: suffix = %s\n", __func__, suffix);
|
||
|
|
|
||
|
|
for (i = 0; i < amp_group->num_amps; i++) {
|
||
|
|
if (amp_group->amps[i].bd.bd_suffix) {
|
||
|
|
pr_debug("%s: comparing %s & %s\n", __func__,
|
||
|
|
amp_group->amps[i].bd.bd_suffix, suffix);
|
||
|
|
if (!strcmp(amp_group->amps[i].bd.bd_suffix, suffix))
|
||
|
|
return &_group->amps[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (i = 0; i < amp_group->num_amps; i++) {
|
||
|
|
pr_debug("%s: comparing %s & %s\n", __func__,
|
||
|
|
amp_group->amps[i].mfd_suffix, suffix);
|
||
|
|
if (!strcmp(amp_group->amps[i].mfd_suffix, suffix))
|
||
|
|
return &_group->amps[i];
|
||
|
|
}
|
||
|
|
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
EXPORT_SYMBOL_GPL(cirrus_get_amp_from_suffix);
|
||
|
|
|
||
|
|
void cirrus_amp_register_i2c_error_callback(const char *suffix, void *func)
|
||
|
|
{
|
||
|
|
struct cirrus_amp *amp = cirrus_get_amp_from_suffix(suffix);
|
||
|
|
|
||
|
|
if (amp)
|
||
|
|
amp->i2c_callback = func;
|
||
|
|
}
|
||
|
|
EXPORT_SYMBOL_GPL(cirrus_amp_register_i2c_error_callback);
|
||
|
|
|
||
|
|
void cirrus_amp_register_error_callback(const char *suffix, void *func)
|
||
|
|
{
|
||
|
|
struct cirrus_amp *amp = cirrus_get_amp_from_suffix(suffix);
|
||
|
|
|
||
|
|
if (amp)
|
||
|
|
amp->error_callback = func;
|
||
|
|
}
|
||
|
|
EXPORT_SYMBOL_GPL(cirrus_amp_register_error_callback);
|
||
|
|
|
||
|
|
int cirrus_amp_add(const char *mfd_suffix, struct cirrus_amp_config cfg)
|
||
|
|
{
|
||
|
|
struct cirrus_amp *amp = cirrus_get_amp_from_suffix(mfd_suffix);
|
||
|
|
|
||
|
|
if (amp) {
|
||
|
|
dev_info(amp_group->cal_dev,
|
||
|
|
"Amp added, suffix: %s dsp_part_name: %s\n",
|
||
|
|
mfd_suffix, cfg.dsp_part_name);
|
||
|
|
|
||
|
|
amp->component = cfg.component;
|
||
|
|
amp->regmap = cfg.regmap;
|
||
|
|
amp->dsp_part_name = cfg.dsp_part_name;
|
||
|
|
amp->num_pre_configs = cfg.num_pre_configs;
|
||
|
|
amp->num_post_configs = cfg.num_post_configs;
|
||
|
|
amp->mbox_cmd = cfg.mbox_cmd;
|
||
|
|
amp->mbox_sts = cfg.mbox_sts;
|
||
|
|
amp->global_en = cfg.global_en;
|
||
|
|
amp->global_en_mask = cfg.global_en_mask;
|
||
|
|
amp->vimon_alg_id = cfg.vimon_alg_id;
|
||
|
|
amp->pwr.target_temp = cfg.target_temp;
|
||
|
|
amp->pwr.exit_temp = cfg.exit_temp;
|
||
|
|
amp->perform_vimon_cal = cfg.perform_vimon_cal;
|
||
|
|
amp->calibration_disable = cfg.calibration_disable;
|
||
|
|
amp->cal_vpk_id = cfg.cal_vpk_id ? cfg.cal_vpk_id :
|
||
|
|
CIRRUS_CAL_RTLOG_ID_V_PEAK;
|
||
|
|
amp->cal_ipk_id = cfg.cal_ipk_id ? cfg.cal_ipk_id :
|
||
|
|
CIRRUS_CAL_RTLOG_ID_I_PEAK;
|
||
|
|
amp->halo_alg_id = cfg.halo_alg_id ? cfg.halo_alg_id :
|
||
|
|
CIRRUS_AMP_ALG_ID_HALO;
|
||
|
|
amp->bd.bd_alg_id = cfg.bd_alg_id ? cfg.bd_alg_id :
|
||
|
|
CIRRUS_AMP_ALG_ID_CSPL;
|
||
|
|
amp->bd.bd_prefix = cfg.bd_prefix ? cfg.bd_prefix :
|
||
|
|
"BDLOG_";
|
||
|
|
amp->cal_vsc_ub = cfg.cal_vsc_ub ? cfg.cal_vsc_ub :
|
||
|
|
CIRRUS_CAL_VIMON_CAL_VSC_UB;
|
||
|
|
amp->cal_vsc_lb = cfg.cal_vsc_lb ? cfg.cal_vsc_lb :
|
||
|
|
CIRRUS_CAL_VIMON_CAL_VSC_LB;
|
||
|
|
amp->cal_isc_ub = cfg.cal_isc_ub ? cfg.cal_isc_ub :
|
||
|
|
CIRRUS_CAL_VIMON_CAL_ISC_UB;
|
||
|
|
amp->cal_isc_lb = cfg.cal_isc_lb ? cfg.cal_isc_lb :
|
||
|
|
CIRRUS_CAL_VIMON_CAL_ISC_LB;
|
||
|
|
amp->bd.max_temp_limit = cfg.bd_max_temp ?
|
||
|
|
cfg.bd_max_temp - 1 : 99;
|
||
|
|
amp->default_redc = cfg.default_redc ? cfg.default_redc :
|
||
|
|
CIRRUS_CAL_RDC_DEFAULT;
|
||
|
|
amp->cal_ops = cfg.cal_ops_idx ? cirrus_cal_ops[cfg.cal_ops_idx] :
|
||
|
|
cirrus_cal_ops[CIRRUS_CAL_CSPL_CAL_OPS_IDX];
|
||
|
|
|
||
|
|
amp->pre_config = kcalloc(cfg.num_pre_configs,
|
||
|
|
sizeof(struct reg_sequence),
|
||
|
|
GFP_KERNEL);
|
||
|
|
|
||
|
|
amp->post_config = kcalloc(cfg.num_post_configs,
|
||
|
|
sizeof(struct reg_sequence),
|
||
|
|
GFP_KERNEL);
|
||
|
|
|
||
|
|
amp->amp_reinit = cfg.amp_reinit;
|
||
|
|
amp->runtime_pm = cfg.runtime_pm;
|
||
|
|
|
||
|
|
amp_group->pwr_enable |= cfg.pwr_enable;
|
||
|
|
|
||
|
|
memcpy(amp->pre_config, cfg.pre_config,
|
||
|
|
sizeof(struct reg_sequence) * cfg.num_pre_configs);
|
||
|
|
|
||
|
|
memcpy(amp->post_config, cfg.post_config,
|
||
|
|
sizeof(struct reg_sequence) * cfg.num_post_configs);
|
||
|
|
} else {
|
||
|
|
dev_err(amp_group->cal_dev,
|
||
|
|
"No amp with suffix %s registered\n", mfd_suffix);
|
||
|
|
return -EINVAL;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
EXPORT_SYMBOL_GPL(cirrus_amp_add);
|
||
|
|
|
||
|
|
int cirrus_amp_read_ctl(struct cirrus_amp *amp, const char *name,
|
||
|
|
int type, unsigned int id, unsigned int *value)
|
||
|
|
{
|
||
|
|
struct wm_adsp *dsp;
|
||
|
|
unsigned int tmp;
|
||
|
|
int ret = 0;
|
||
|
|
|
||
|
|
if (amp && amp->component)
|
||
|
|
dsp = snd_soc_component_get_drvdata(amp->component);
|
||
|
|
else
|
||
|
|
return -EINVAL;
|
||
|
|
|
||
|
|
if (dsp) {
|
||
|
|
ret = wm_adsp_read_ctl(dsp, name, type, id, (void *)&tmp, 4);
|
||
|
|
*value = (tmp & 0xff0000) >> 8 |
|
||
|
|
(tmp & 0xff00) << 8 |
|
||
|
|
(tmp & 0xff000000) >> 24;
|
||
|
|
}
|
||
|
|
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
EXPORT_SYMBOL_GPL(cirrus_amp_read_ctl);
|
||
|
|
|
||
|
|
int cirrus_amp_write_ctl(struct cirrus_amp *amp, const char *name,
|
||
|
|
int type, unsigned int id, unsigned int value)
|
||
|
|
{
|
||
|
|
struct wm_adsp *dsp;
|
||
|
|
unsigned int tmp;
|
||
|
|
|
||
|
|
if (amp && amp->component)
|
||
|
|
dsp = snd_soc_component_get_drvdata(amp->component);
|
||
|
|
else
|
||
|
|
return -EINVAL;
|
||
|
|
|
||
|
|
tmp = (value & 0xff0000) >> 8 |
|
||
|
|
(value & 0xff00) << 8 |
|
||
|
|
(value & 0xff000000) >> 24 |
|
||
|
|
(value & 0xff) << 24;
|
||
|
|
|
||
|
|
if (dsp)
|
||
|
|
return wm_adsp_write_ctl(dsp, name, type, id, (void *)&tmp, 4);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
EXPORT_SYMBOL_GPL(cirrus_amp_write_ctl);
|
||
|
|
|
||
|
|
static const struct of_device_id cirrus_amp_of_match[] = {
|
||
|
|
{ .compatible = "cirrus-amp", },
|
||
|
|
{},
|
||
|
|
};
|
||
|
|
MODULE_DEVICE_TABLE(of, cirrus_amp_of_match);
|
||
|
|
|
||
|
|
static int cirrus_amp_probe(struct platform_device *pdev)
|
||
|
|
{
|
||
|
|
struct device_node *np;
|
||
|
|
struct device_node *amp_node;
|
||
|
|
const char **mfd_suffixes;
|
||
|
|
const char **bd_suffixes;
|
||
|
|
bool v_val_separate[CIRRUS_MAX_AMPS];
|
||
|
|
int ret = 0, num = 0, num_amps, i, j;
|
||
|
|
|
||
|
|
cirrus_amp_class = class_create(THIS_MODULE, "cirrus");
|
||
|
|
if (IS_ERR(cirrus_amp_class)) {
|
||
|
|
ret = PTR_ERR(cirrus_amp_class);
|
||
|
|
pr_err("%s: Unable to register cirrus_amp class (%d)",
|
||
|
|
__func__, ret);
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
for_each_matching_node(np, cirrus_amp_of_match)
|
||
|
|
num++;
|
||
|
|
|
||
|
|
if (num != 1) {
|
||
|
|
pr_info("%s: Exactly 1 OF entry is allowed (%d detected)\n",
|
||
|
|
__func__, num);
|
||
|
|
ret = -EINVAL;
|
||
|
|
goto class_err;
|
||
|
|
}
|
||
|
|
|
||
|
|
np = of_find_matching_node(NULL, cirrus_amp_of_match);
|
||
|
|
if (!np) {
|
||
|
|
pr_err("%s: Device node required\n", __func__);
|
||
|
|
ret = -ENODEV;
|
||
|
|
goto class_err;
|
||
|
|
}
|
||
|
|
|
||
|
|
num_amps = of_count_phandle_with_args(np, "cirrus,amps", NULL);
|
||
|
|
if (num_amps <= 0) {
|
||
|
|
pr_err("%s: Failed to parse 'cirrus,amps'\n", __func__);
|
||
|
|
ret = -ENODEV;
|
||
|
|
goto class_err;
|
||
|
|
}
|
||
|
|
|
||
|
|
amp_group = kzalloc(sizeof(struct cirrus_amp_group) +
|
||
|
|
sizeof(struct cirrus_amp) * num_amps,
|
||
|
|
GFP_KERNEL);
|
||
|
|
mfd_suffixes = kcalloc(num_amps, sizeof(char *), GFP_KERNEL);
|
||
|
|
bd_suffixes = kcalloc(num_amps, sizeof(char *), GFP_KERNEL);
|
||
|
|
|
||
|
|
amp_group->num_amps = num_amps;
|
||
|
|
|
||
|
|
for (i = 0; i < num_amps; i++) {
|
||
|
|
amp_node = of_parse_phandle(np, "cirrus,amps", i);
|
||
|
|
if (IS_ERR(amp_node)) {
|
||
|
|
pr_err("%s: Failed to parse 'cirrus,amps' (%d)\n",
|
||
|
|
__func__, i);
|
||
|
|
ret = PTR_ERR(amp_node);
|
||
|
|
goto suffix_free;
|
||
|
|
}
|
||
|
|
|
||
|
|
pr_debug("%s: Found linked amp: %s\n", __func__,
|
||
|
|
amp_node->full_name);
|
||
|
|
|
||
|
|
ret = of_property_read_string(amp_node, "cirrus,mfd-suffix",
|
||
|
|
&mfd_suffixes[i]);
|
||
|
|
if (ret < 0) {
|
||
|
|
pr_err("%s: No MFD suffix found for amp: %s\n",
|
||
|
|
__func__, amp_node->full_name);
|
||
|
|
|
||
|
|
of_node_put(amp_node);
|
||
|
|
goto suffix_free;
|
||
|
|
}
|
||
|
|
|
||
|
|
ret = of_property_read_string(amp_node, "cirrus,bd-suffix",
|
||
|
|
&bd_suffixes[i]);
|
||
|
|
if (ret < 0)
|
||
|
|
pr_debug("%s: No BD suffix found for amp: %s\n",
|
||
|
|
__func__, amp_node->full_name);
|
||
|
|
|
||
|
|
v_val_separate[i] = of_property_read_bool(amp_node,
|
||
|
|
"cirrus,v-val_separate");
|
||
|
|
|
||
|
|
of_node_put(amp_node);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (i = 0; i < num_amps; i++) {
|
||
|
|
for (j = 0; j < num_amps; j++) {
|
||
|
|
if (i == j)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
if (strcmp(mfd_suffixes[i], mfd_suffixes[j]) == 0) {
|
||
|
|
pr_err("%s: MFD suffixes must be unique\n",
|
||
|
|
__func__);
|
||
|
|
pr_err("%s: Found duplicate suffix: %s\n",
|
||
|
|
__func__, mfd_suffixes[i]);
|
||
|
|
|
||
|
|
ret = -EINVAL;
|
||
|
|
goto suffix_err;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* bd_suffixes can be empty but must be unique */
|
||
|
|
if (bd_suffixes[i] && bd_suffixes[j] &&
|
||
|
|
(strcmp(bd_suffixes[i], bd_suffixes[j]) == 0)) {
|
||
|
|
pr_err("%s: BD suffixes must be unique\n",
|
||
|
|
__func__);
|
||
|
|
pr_err("%s: Found duplicate suffix: %s\n",
|
||
|
|
__func__, bd_suffixes[i]);
|
||
|
|
|
||
|
|
ret = -EINVAL;
|
||
|
|
goto suffix_err;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pr_info("%s: Found MFD suffix: %s\n", __func__,
|
||
|
|
mfd_suffixes[i]);
|
||
|
|
|
||
|
|
amp_group->amps[i].mfd_suffix =
|
||
|
|
kstrdup(mfd_suffixes[i], GFP_KERNEL);
|
||
|
|
|
||
|
|
if (bd_suffixes[i]) {
|
||
|
|
pr_info("%s: Found BD suffix: %s\n", __func__,
|
||
|
|
bd_suffixes[i]);
|
||
|
|
|
||
|
|
amp_group->amps[i].bd.bd_suffix =
|
||
|
|
kstrdup(bd_suffixes[i], GFP_KERNEL);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (v_val_separate[i])
|
||
|
|
amp_group->amps[i].v_val_separate = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
ret = cirrus_bd_init();
|
||
|
|
if (ret < 0) {
|
||
|
|
pr_err("%s: Error in BD init (%d)\n", __func__, ret);
|
||
|
|
goto suffix_err;
|
||
|
|
}
|
||
|
|
|
||
|
|
ret = cirrus_cal_init();
|
||
|
|
if (ret < 0) {
|
||
|
|
pr_err("%s: Error in CAL init (%d)\n", __func__, ret);
|
||
|
|
cirrus_bd_exit();
|
||
|
|
goto suffix_err;
|
||
|
|
}
|
||
|
|
|
||
|
|
ret = cirrus_pwr_init();
|
||
|
|
if (ret < 0) {
|
||
|
|
pr_err("%s: Error in PWR init (%d)\n", __func__, ret);
|
||
|
|
cirrus_bd_exit();
|
||
|
|
cirrus_cal_exit();
|
||
|
|
goto suffix_err;
|
||
|
|
}
|
||
|
|
|
||
|
|
ret = 0;
|
||
|
|
|
||
|
|
goto suffix_free;
|
||
|
|
|
||
|
|
suffix_err:
|
||
|
|
for (i = 0; i < num_amps; i++) {
|
||
|
|
kfree(amp_group->amps[i].mfd_suffix);
|
||
|
|
kfree(amp_group->amps[i].bd.bd_suffix);
|
||
|
|
}
|
||
|
|
|
||
|
|
suffix_free:
|
||
|
|
kfree(mfd_suffixes);
|
||
|
|
kfree(bd_suffixes);
|
||
|
|
|
||
|
|
if (ret < 0)
|
||
|
|
kfree(amp_group);
|
||
|
|
|
||
|
|
class_err:
|
||
|
|
if (ret < 0)
|
||
|
|
class_destroy(cirrus_amp_class);
|
||
|
|
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int cirrus_amp_remove(struct platform_device *pdev)
|
||
|
|
{
|
||
|
|
int i;
|
||
|
|
|
||
|
|
cirrus_cal_exit();
|
||
|
|
cirrus_bd_exit();
|
||
|
|
cirrus_pwr_exit();
|
||
|
|
|
||
|
|
for (i = 0; i < amp_group->num_amps; i++) {
|
||
|
|
kfree(amp_group->amps[i].pre_config);
|
||
|
|
kfree(amp_group->amps[i].post_config);
|
||
|
|
}
|
||
|
|
|
||
|
|
kfree(amp_group);
|
||
|
|
|
||
|
|
class_destroy(cirrus_amp_class);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static struct platform_driver cirrus_amp_driver = {
|
||
|
|
.driver = {
|
||
|
|
.name = "cirrus-amp",
|
||
|
|
.of_match_table = cirrus_amp_of_match,
|
||
|
|
},
|
||
|
|
.probe = cirrus_amp_probe,
|
||
|
|
.remove = cirrus_amp_remove,
|
||
|
|
};
|
||
|
|
module_platform_driver(cirrus_amp_driver);
|
||
|
|
|
||
|
|
MODULE_AUTHOR("David Rhodes <David.Rhodes@cirrus.com>");
|
||
|
|
MODULE_DESCRIPTION("Cirrus Amp driver");
|
||
|
|
MODULE_LICENSE("GPL");
|
||
|
|
|