250 lines · c
1// SPDX-License-Identifier: GPL-2.02//3// HDA DSP ALSA Control Driver4//5// Copyright 2022 Cirrus Logic, Inc.6//7// Author: Stefan Binding <sbinding@opensource.cirrus.com>8 9#include <linux/module.h>10#include <sound/soc.h>11#include <linux/cleanup.h>12#include <linux/firmware/cirrus/cs_dsp.h>13#include <linux/firmware/cirrus/wmfw.h>14#include "hda_cs_dsp_ctl.h"15 16#define ADSP_MAX_STD_CTRL_SIZE 51217 18struct hda_cs_dsp_coeff_ctl {19 struct cs_dsp_coeff_ctl *cs_ctl;20 struct snd_card *card;21 struct snd_kcontrol *kctl;22};23 24static const char * const hda_cs_dsp_fw_text[HDA_CS_DSP_NUM_FW] = {25 [HDA_CS_DSP_FW_SPK_PROT] = "Prot",26 [HDA_CS_DSP_FW_SPK_CALI] = "Cali",27 [HDA_CS_DSP_FW_SPK_DIAG] = "Diag",28 [HDA_CS_DSP_FW_MISC] = "Misc",29};30 31const char * const hda_cs_dsp_fw_ids[HDA_CS_DSP_NUM_FW] = {32 [HDA_CS_DSP_FW_SPK_PROT] = "spk-prot",33 [HDA_CS_DSP_FW_SPK_CALI] = "spk-cali",34 [HDA_CS_DSP_FW_SPK_DIAG] = "spk-diag",35 [HDA_CS_DSP_FW_MISC] = "misc",36};37EXPORT_SYMBOL_NS_GPL(hda_cs_dsp_fw_ids, SND_HDA_CS_DSP_CONTROLS);38 39static int hda_cs_dsp_coeff_info(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)40{41 struct hda_cs_dsp_coeff_ctl *ctl = (struct hda_cs_dsp_coeff_ctl *)snd_kcontrol_chip(kctl);42 struct cs_dsp_coeff_ctl *cs_ctl = ctl->cs_ctl;43 44 uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;45 uinfo->count = cs_ctl->len;46 47 return 0;48}49 50static int hda_cs_dsp_coeff_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)51{52 struct hda_cs_dsp_coeff_ctl *ctl = (struct hda_cs_dsp_coeff_ctl *)snd_kcontrol_chip(kctl);53 struct cs_dsp_coeff_ctl *cs_ctl = ctl->cs_ctl;54 char *p = ucontrol->value.bytes.data;55 56 return cs_dsp_coeff_lock_and_write_ctrl(cs_ctl, 0, p, cs_ctl->len);57}58 59static int hda_cs_dsp_coeff_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)60{61 struct hda_cs_dsp_coeff_ctl *ctl = (struct hda_cs_dsp_coeff_ctl *)snd_kcontrol_chip(kctl);62 struct cs_dsp_coeff_ctl *cs_ctl = ctl->cs_ctl;63 char *p = ucontrol->value.bytes.data;64 65 return cs_dsp_coeff_lock_and_read_ctrl(cs_ctl, 0, p, cs_ctl->len);66}67 68static unsigned int wmfw_convert_flags(unsigned int in)69{70 unsigned int out, rd, wr, vol;71 72 rd = SNDRV_CTL_ELEM_ACCESS_READ;73 wr = SNDRV_CTL_ELEM_ACCESS_WRITE;74 vol = SNDRV_CTL_ELEM_ACCESS_VOLATILE;75 76 out = 0;77 78 if (in) {79 out |= rd;80 if (in & WMFW_CTL_FLAG_WRITEABLE)81 out |= wr;82 if (in & WMFW_CTL_FLAG_VOLATILE)83 out |= vol;84 } else {85 out |= rd | wr | vol;86 }87 88 return out;89}90 91static void hda_cs_dsp_free_kcontrol(struct snd_kcontrol *kctl)92{93 struct hda_cs_dsp_coeff_ctl *ctl = (struct hda_cs_dsp_coeff_ctl *)snd_kcontrol_chip(kctl);94 struct cs_dsp_coeff_ctl *cs_ctl = ctl->cs_ctl;95 96 /* NULL priv to prevent a double-free in hda_cs_dsp_control_remove() */97 cs_ctl->priv = NULL;98 kfree(ctl);99}100 101static void hda_cs_dsp_add_kcontrol(struct cs_dsp_coeff_ctl *cs_ctl,102 const struct hda_cs_dsp_ctl_info *info,103 const char *name)104{105 struct snd_kcontrol_new kcontrol = {0};106 struct snd_kcontrol *kctl;107 struct hda_cs_dsp_coeff_ctl *ctl __free(kfree) = NULL;108 int ret = 0;109 110 if (cs_ctl->len > ADSP_MAX_STD_CTRL_SIZE) {111 dev_err(cs_ctl->dsp->dev, "KControl %s: length %zu exceeds maximum %d\n", name,112 cs_ctl->len, ADSP_MAX_STD_CTRL_SIZE);113 return;114 }115 116 ctl = kzalloc(sizeof(*ctl), GFP_KERNEL);117 if (!ctl)118 return;119 120 ctl->cs_ctl = cs_ctl;121 ctl->card = info->card;122 123 kcontrol.name = name;124 kcontrol.info = hda_cs_dsp_coeff_info;125 kcontrol.iface = SNDRV_CTL_ELEM_IFACE_MIXER;126 kcontrol.access = wmfw_convert_flags(cs_ctl->flags);127 kcontrol.get = hda_cs_dsp_coeff_get;128 kcontrol.put = hda_cs_dsp_coeff_put;129 130 kctl = snd_ctl_new1(&kcontrol, (void *)ctl);131 if (!kctl)132 return;133 134 kctl->private_free = hda_cs_dsp_free_kcontrol;135 ctl->kctl = kctl;136 137 /* snd_ctl_add() calls our private_free on error, which will kfree(ctl) */138 cs_ctl->priv = no_free_ptr(ctl);139 ret = snd_ctl_add(info->card, kctl);140 if (ret) {141 dev_err(cs_ctl->dsp->dev, "Failed to add KControl %s = %d\n", kcontrol.name, ret);142 return;143 }144 145 dev_dbg(cs_ctl->dsp->dev, "Added KControl: %s\n", kcontrol.name);146}147 148static void hda_cs_dsp_control_add(struct cs_dsp_coeff_ctl *cs_ctl,149 const struct hda_cs_dsp_ctl_info *info)150{151 struct cs_dsp *cs_dsp = cs_ctl->dsp;152 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];153 const char *region_name;154 int ret;155 156 region_name = cs_dsp_mem_region_name(cs_ctl->alg_region.type);157 if (!region_name) {158 dev_warn(cs_dsp->dev, "Unknown region type: %d\n", cs_ctl->alg_region.type);159 return;160 }161 162 ret = scnprintf(name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s %s %.12s %x", info->device_name,163 cs_dsp->name, hda_cs_dsp_fw_text[info->fw_type], cs_ctl->alg_region.alg);164 165 if (cs_ctl->subname) {166 int avail = SNDRV_CTL_ELEM_ID_NAME_MAXLEN - ret - 2;167 int skip = 0;168 169 /* Truncate the subname from the start if it is too long */170 if (cs_ctl->subname_len > avail)171 skip = cs_ctl->subname_len - avail;172 173 snprintf(name + ret, SNDRV_CTL_ELEM_ID_NAME_MAXLEN - ret,174 " %.*s", cs_ctl->subname_len - skip, cs_ctl->subname + skip);175 }176 177 hda_cs_dsp_add_kcontrol(cs_ctl, info, name);178}179 180void hda_cs_dsp_add_controls(struct cs_dsp *dsp, const struct hda_cs_dsp_ctl_info *info)181{182 struct cs_dsp_coeff_ctl *cs_ctl;183 184 /*185 * pwr_lock would cause mutex inversion with ALSA control lock compared186 * to the get/put functions.187 * It is safe to walk the list without holding a mutex because entries188 * are persistent and only cs_dsp_power_up() or cs_dsp_remove() can189 * change the list.190 */191 lockdep_assert_not_held(&dsp->pwr_lock);192 193 list_for_each_entry(cs_ctl, &dsp->ctl_list, list) {194 if (cs_ctl->flags & WMFW_CTL_FLAG_SYS)195 continue;196 197 if (cs_ctl->priv)198 continue;199 200 hda_cs_dsp_control_add(cs_ctl, info);201 }202}203EXPORT_SYMBOL_NS_GPL(hda_cs_dsp_add_controls, SND_HDA_CS_DSP_CONTROLS);204 205void hda_cs_dsp_control_remove(struct cs_dsp_coeff_ctl *cs_ctl)206{207 struct hda_cs_dsp_coeff_ctl *ctl = cs_ctl->priv;208 209 /* ctl and kctl may already have been removed by ALSA private_free */210 if (ctl)211 snd_ctl_remove(ctl->card, ctl->kctl);212}213EXPORT_SYMBOL_NS_GPL(hda_cs_dsp_control_remove, SND_HDA_CS_DSP_CONTROLS);214 215int hda_cs_dsp_write_ctl(struct cs_dsp *dsp, const char *name, int type,216 unsigned int alg, const void *buf, size_t len)217{218 struct cs_dsp_coeff_ctl *cs_ctl;219 int ret;220 221 mutex_lock(&dsp->pwr_lock);222 cs_ctl = cs_dsp_get_ctl(dsp, name, type, alg);223 ret = cs_dsp_coeff_write_ctrl(cs_ctl, 0, buf, len);224 mutex_unlock(&dsp->pwr_lock);225 if (ret < 0)226 return ret;227 228 return 0;229}230EXPORT_SYMBOL_NS_GPL(hda_cs_dsp_write_ctl, SND_HDA_CS_DSP_CONTROLS);231 232int hda_cs_dsp_read_ctl(struct cs_dsp *dsp, const char *name, int type,233 unsigned int alg, void *buf, size_t len)234{235 int ret;236 237 mutex_lock(&dsp->pwr_lock);238 ret = cs_dsp_coeff_read_ctrl(cs_dsp_get_ctl(dsp, name, type, alg), 0, buf, len);239 mutex_unlock(&dsp->pwr_lock);240 241 return ret;242 243}244EXPORT_SYMBOL_NS_GPL(hda_cs_dsp_read_ctl, SND_HDA_CS_DSP_CONTROLS);245 246MODULE_DESCRIPTION("CS_DSP ALSA Control HDA Library");247MODULE_AUTHOR("Stefan Binding, <sbinding@opensource.cirrus.com>");248MODULE_LICENSE("GPL");249MODULE_IMPORT_NS(FW_CS_DSP);250