1// SPDX-License-Identifier: GPL-2.0
2// Copyright (C) 2025 Cirrus Logic, Inc. and
3// Cirrus Logic International Semiconductor Ltd.
4
5/*
6 * The MIPI SDCA specification is available for public downloads at
7 * https://www.mipi.org/mipi-sdca-v1-0-download
8 */
9
10#include <linux/auxiliary_bus.h>
11#include <linux/minmax.h>
12#include <linux/module.h>
13#include <linux/pm.h>
14#include <linux/pm_runtime.h>
15#include <linux/soundwire/sdw.h>
16#include <linux/soundwire/sdw_registers.h>
17#include <sound/pcm.h>
18#include <sound/sdca_asoc.h>
19#include <sound/sdca_fdl.h>
20#include <sound/sdca_function.h>
21#include <sound/sdca_interrupts.h>
22#include <sound/sdca_regmap.h>
23#include <sound/sdw.h>
24#include <sound/soc-component.h>
25#include <sound/soc-dai.h>
26#include <sound/soc.h>
27#include "sdca_class.h"
28
29struct class_function_drv {
30 struct device *dev;
31 struct regmap *regmap;
32 struct sdca_class_drv *core;
33
34 struct sdca_function_data *function;
35};
36
37static void class_function_regmap_lock(void *data)
38{
39 struct mutex *lock = data;
40
41 mutex_lock(lock);
42}
43
44static void class_function_regmap_unlock(void *data)
45{
46 struct mutex *lock = data;
47
48 mutex_unlock(lock);
49}
50
51static bool class_function_regmap_writeable(struct device *dev, unsigned int reg)
52{
53 struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
54 struct class_function_drv *drv = auxiliary_get_drvdata(auxdev);
55
56 return sdca_regmap_writeable(function: drv->function, reg);
57}
58
59static bool class_function_regmap_readable(struct device *dev, unsigned int reg)
60{
61 struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
62 struct class_function_drv *drv = auxiliary_get_drvdata(auxdev);
63
64 return sdca_regmap_readable(function: drv->function, reg);
65}
66
67static bool class_function_regmap_volatile(struct device *dev, unsigned int reg)
68{
69 struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
70 struct class_function_drv *drv = auxiliary_get_drvdata(auxdev);
71
72 return sdca_regmap_volatile(function: drv->function, reg);
73}
74
75static const struct regmap_config class_function_regmap_config = {
76 .name = "sdca",
77 .reg_bits = 32,
78 .val_bits = 32,
79 .reg_format_endian = REGMAP_ENDIAN_LITTLE,
80 .val_format_endian = REGMAP_ENDIAN_LITTLE,
81
82 .max_register = SDW_SDCA_MAX_REGISTER,
83 .readable_reg = class_function_regmap_readable,
84 .writeable_reg = class_function_regmap_writeable,
85 .volatile_reg = class_function_regmap_volatile,
86
87 .cache_type = REGCACHE_MAPLE,
88
89 .lock = class_function_regmap_lock,
90 .unlock = class_function_regmap_unlock,
91};
92
93static int class_function_regmap_mbq_size(struct device *dev, unsigned int reg)
94{
95 struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
96 struct class_function_drv *drv = auxiliary_get_drvdata(auxdev);
97
98 return sdca_regmap_mbq_size(function: drv->function, reg);
99}
100
101static bool class_function_regmap_deferrable(struct device *dev, unsigned int reg)
102{
103 struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
104 struct class_function_drv *drv = auxiliary_get_drvdata(auxdev);
105
106 return sdca_regmap_deferrable(function: drv->function, reg);
107}
108
109static const struct regmap_sdw_mbq_cfg class_function_mbq_config = {
110 .mbq_size = class_function_regmap_mbq_size,
111 .deferrable = class_function_regmap_deferrable,
112 .retry_us = 1000,
113 .timeout_us = 10000,
114};
115
116static int class_function_startup(struct snd_pcm_substream *substream,
117 struct snd_soc_dai *dai)
118{
119 struct class_function_drv *drv = snd_soc_component_get_drvdata(c: dai->component);
120
121 return sdca_asoc_set_constraints(dev: drv->dev, regmap: drv->regmap, function: drv->function,
122 substream, dai);
123}
124
125static int class_function_sdw_add_peripheral(struct snd_pcm_substream *substream,
126 struct snd_pcm_hw_params *params,
127 struct snd_soc_dai *dai)
128{
129 struct class_function_drv *drv = snd_soc_component_get_drvdata(c: dai->component);
130 struct sdw_stream_runtime *sdw_stream = snd_soc_dai_get_dma_data(dai, substream);
131 struct sdw_slave *sdw = dev_to_sdw_dev(drv->dev->parent);
132 struct sdw_stream_config sconfig = {0};
133 struct sdw_port_config pconfig = {0};
134 int ret;
135
136 if (!sdw_stream)
137 return -EINVAL;
138
139 snd_sdw_params_to_config(substream, params, stream_config: &sconfig, port_config: &pconfig);
140
141 /*
142 * FIXME: As also noted in sdca_asoc_get_port(), currently only
143 * a single unshared port is supported for each DAI.
144 */
145 ret = sdca_asoc_get_port(dev: drv->dev, regmap: drv->regmap, function: drv->function, dai);
146 if (ret < 0)
147 return ret;
148
149 pconfig.num = ret;
150
151 ret = sdw_stream_add_slave(slave: sdw, stream_config: &sconfig, port_config: &pconfig, num_ports: 1, stream: sdw_stream);
152 if (ret) {
153 dev_err(drv->dev, "failed to add sdw stream: %d\n", ret);
154 return ret;
155 }
156
157 return sdca_asoc_hw_params(dev: drv->dev, regmap: drv->regmap, function: drv->function,
158 substream, params, dai);
159}
160
161static int class_function_sdw_remove_peripheral(struct snd_pcm_substream *substream,
162 struct snd_soc_dai *dai)
163{
164 struct class_function_drv *drv = snd_soc_component_get_drvdata(c: dai->component);
165 struct sdw_stream_runtime *sdw_stream = snd_soc_dai_get_dma_data(dai, substream);
166 struct sdw_slave *sdw = dev_to_sdw_dev(drv->dev->parent);
167
168 if (!sdw_stream)
169 return -EINVAL;
170
171 return sdw_stream_remove_slave(slave: sdw, stream: sdw_stream);
172}
173
174static int class_function_sdw_set_stream(struct snd_soc_dai *dai, void *sdw_stream,
175 int direction)
176{
177 snd_soc_dai_dma_data_set(dai, stream: direction, data: sdw_stream);
178
179 return 0;
180}
181
182static const struct snd_soc_dai_ops class_function_sdw_ops = {
183 .startup = class_function_startup,
184 .shutdown = sdca_asoc_free_constraints,
185 .set_stream = class_function_sdw_set_stream,
186 .hw_params = class_function_sdw_add_peripheral,
187 .hw_free = class_function_sdw_remove_peripheral,
188};
189
190static int class_function_component_probe(struct snd_soc_component *component)
191{
192 struct class_function_drv *drv = snd_soc_component_get_drvdata(c: component);
193 struct sdca_class_drv *core = drv->core;
194
195 return sdca_irq_populate(function: drv->function, component, info: core->irq_info);
196}
197
198static const struct snd_soc_component_driver class_function_component_drv = {
199 .probe = class_function_component_probe,
200 .endianness = 1,
201};
202
203static int class_function_boot(struct class_function_drv *drv)
204{
205 unsigned int reg = SDW_SDCA_CTL(drv->function->desc->adr,
206 SDCA_ENTITY_TYPE_ENTITY_0,
207 SDCA_CTL_ENTITY_0_FUNCTION_STATUS, 0);
208 unsigned int val;
209 int ret;
210
211 ret = regmap_read(map: drv->regmap, reg, val: &val);
212 if (ret < 0) {
213 dev_err(drv->dev, "failed to read function status: %d\n", ret);
214 return ret;
215 }
216
217 if (!(val & SDCA_CTL_ENTITY_0_FUNCTION_HAS_BEEN_RESET)) {
218 dev_dbg(drv->dev, "reset function device\n");
219
220 ret = sdca_reset_function(dev: drv->dev, function: drv->function, regmap: drv->regmap);
221 if (ret)
222 return ret;
223 }
224
225 if (val & SDCA_CTL_ENTITY_0_FUNCTION_NEEDS_INITIALIZATION) {
226 dev_dbg(drv->dev, "write initialisation\n");
227
228 ret = sdca_regmap_write_init(dev: drv->dev, regmap: drv->core->dev_regmap,
229 function: drv->function);
230 if (ret)
231 return ret;
232
233 ret = regmap_write(map: drv->regmap, reg,
234 val: SDCA_CTL_ENTITY_0_FUNCTION_NEEDS_INITIALIZATION);
235 if (ret < 0) {
236 dev_err(drv->dev,
237 "failed to clear function init status: %d\n",
238 ret);
239 return ret;
240 }
241 }
242
243 /* Start FDL process */
244 ret = sdca_irq_populate_early(dev: drv->dev, function_regmap: drv->regmap, function: drv->function,
245 info: drv->core->irq_info);
246 if (ret)
247 return ret;
248
249 ret = sdca_fdl_sync(dev: drv->dev, function: drv->function, info: drv->core->irq_info);
250 if (ret)
251 return ret;
252
253 ret = sdca_regmap_write_defaults(dev: drv->dev, regmap: drv->regmap, function: drv->function);
254 if (ret)
255 return ret;
256
257 ret = regmap_write(map: drv->regmap, reg, val: 0xFF);
258 if (ret < 0) {
259 dev_err(drv->dev, "failed to clear function status: %d\n", ret);
260 return ret;
261 }
262
263 return 0;
264}
265
266static int class_function_probe(struct auxiliary_device *auxdev,
267 const struct auxiliary_device_id *aux_dev_id)
268{
269 struct device *dev = &auxdev->dev;
270 struct sdca_class_drv *core = dev_get_drvdata(dev: dev->parent);
271 struct sdca_device_data *data = &core->sdw->sdca_data;
272 struct sdca_function_desc *desc;
273 struct snd_soc_component_driver *cmp_drv;
274 struct snd_soc_dai_driver *dais;
275 struct class_function_drv *drv;
276 struct regmap_sdw_mbq_cfg *mbq_config;
277 struct regmap_config *config;
278 struct reg_default *defaults;
279 int ndefaults;
280 int num_dais;
281 int ret;
282 int i;
283
284 drv = devm_kzalloc(dev, size: sizeof(*drv), GFP_KERNEL);
285 if (!drv)
286 return -ENOMEM;
287
288 cmp_drv = devm_kmemdup(dev, src: &class_function_component_drv, len: sizeof(*cmp_drv),
289 GFP_KERNEL);
290 if (!cmp_drv)
291 return -ENOMEM;
292
293 config = devm_kmemdup(dev, src: &class_function_regmap_config, len: sizeof(*config),
294 GFP_KERNEL);
295 if (!config)
296 return -ENOMEM;
297
298 mbq_config = devm_kmemdup(dev, src: &class_function_mbq_config, len: sizeof(*mbq_config),
299 GFP_KERNEL);
300 if (!mbq_config)
301 return -ENOMEM;
302
303 drv->dev = dev;
304 drv->core = core;
305
306 for (i = 0; i < data->num_functions; i++) {
307 desc = &data->function[i];
308
309 if (desc->type == aux_dev_id->driver_data)
310 break;
311 }
312 if (i == core->sdw->sdca_data.num_functions) {
313 dev_err(dev, "failed to locate function\n");
314 return -EINVAL;
315 }
316
317 drv->function = &core->functions[i];
318
319 ret = sdca_parse_function(dev, sdw: core->sdw, desc, function: drv->function);
320 if (ret)
321 return ret;
322
323 ndefaults = sdca_regmap_count_constants(dev, function: drv->function);
324 if (ndefaults < 0)
325 return ndefaults;
326
327 defaults = devm_kcalloc(dev, n: ndefaults, size: sizeof(*defaults), GFP_KERNEL);
328 if (!defaults)
329 return -ENOMEM;
330
331 ret = sdca_regmap_populate_constants(dev, function: drv->function, consts: defaults);
332 if (ret < 0)
333 return ret;
334
335 regcache_sort_defaults(defaults, ndefaults);
336
337 auxiliary_set_drvdata(auxdev, data: drv);
338
339 config->reg_defaults = defaults;
340 config->num_reg_defaults = ndefaults;
341 config->lock_arg = &core->regmap_lock;
342
343 if (drv->function->busy_max_delay) {
344 mbq_config->timeout_us = drv->function->busy_max_delay;
345 mbq_config->retry_us = umax(drv->function->busy_max_delay / 10,
346 mbq_config->retry_us);
347 }
348
349 drv->regmap = devm_regmap_init_sdw_mbq_cfg(dev, core->sdw, config, mbq_config);
350 if (IS_ERR(ptr: drv->regmap))
351 return dev_err_probe(dev, err: PTR_ERR(ptr: drv->regmap),
352 fmt: "failed to create regmap");
353
354 ret = sdca_asoc_populate_component(dev, function: drv->function, component_drv: cmp_drv,
355 dai_drv: &dais, num_dai_drv: &num_dais,
356 ops: &class_function_sdw_ops);
357 if (ret)
358 return ret;
359
360 pm_runtime_set_autosuspend_delay(dev, delay: 200);
361 pm_runtime_use_autosuspend(dev);
362 pm_runtime_set_active(dev);
363 pm_runtime_get_noresume(dev);
364
365 ret = devm_pm_runtime_enable(dev);
366 if (ret)
367 return ret;
368
369 ret = class_function_boot(drv);
370 if (ret)
371 return ret;
372
373 ret = devm_snd_soc_register_component(dev, component_driver: cmp_drv, dai_drv: dais, num_dai: num_dais);
374 if (ret)
375 return dev_err_probe(dev, err: ret, fmt: "failed to register component\n");
376
377 pm_runtime_mark_last_busy(dev);
378 pm_runtime_put_autosuspend(dev);
379
380 return 0;
381}
382
383static int class_function_runtime_suspend(struct device *dev)
384{
385 struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
386 struct class_function_drv *drv = auxiliary_get_drvdata(auxdev);
387
388 /*
389 * Whilst the driver doesn't power the chip down here, going into
390 * runtime suspend means the driver can't be sure the bus won't
391 * power down which would prevent communication with the device.
392 */
393 regcache_cache_only(map: drv->regmap, enable: true);
394
395 return 0;
396}
397
398static int class_function_runtime_resume(struct device *dev)
399{
400 struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
401 struct class_function_drv *drv = auxiliary_get_drvdata(auxdev);
402 int ret;
403
404 regcache_mark_dirty(map: drv->regmap);
405 regcache_cache_only(map: drv->regmap, enable: false);
406
407 ret = regcache_sync(map: drv->regmap);
408 if (ret) {
409 dev_err(drv->dev, "failed to restore register cache: %d\n", ret);
410 goto err;
411 }
412
413 return 0;
414
415err:
416 regcache_cache_only(map: drv->regmap, enable: true);
417
418 return ret;
419}
420
421static const struct dev_pm_ops class_function_pm_ops = {
422 RUNTIME_PM_OPS(class_function_runtime_suspend,
423 class_function_runtime_resume, NULL)
424};
425
426static const struct auxiliary_device_id class_function_id_table[] = {
427 {
428 .name = "snd_soc_sdca." SDCA_FUNCTION_TYPE_SMART_AMP_NAME,
429 .driver_data = SDCA_FUNCTION_TYPE_SMART_AMP,
430 },
431 {
432 .name = "snd_soc_sdca." SDCA_FUNCTION_TYPE_SMART_MIC_NAME,
433 .driver_data = SDCA_FUNCTION_TYPE_SMART_MIC,
434 },
435 {
436 .name = "snd_soc_sdca." SDCA_FUNCTION_TYPE_UAJ_NAME,
437 .driver_data = SDCA_FUNCTION_TYPE_UAJ,
438 },
439 {
440 .name = "snd_soc_sdca." SDCA_FUNCTION_TYPE_HID_NAME,
441 .driver_data = SDCA_FUNCTION_TYPE_HID,
442 },
443 {},
444};
445MODULE_DEVICE_TABLE(auxiliary, class_function_id_table);
446
447static struct auxiliary_driver class_function_drv = {
448 .driver = {
449 .name = "sdca_function",
450 .pm = pm_ptr(&class_function_pm_ops),
451 },
452
453 .probe = class_function_probe,
454 .id_table = class_function_id_table
455};
456module_auxiliary_driver(class_function_drv);
457
458MODULE_LICENSE("GPL");
459MODULE_DESCRIPTION("SDCA Class Function Driver");
460MODULE_IMPORT_NS("SND_SOC_SDCA");
461

source code of linux/sound/soc/sdca/sdca_class_function.c