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