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/acpi.h>
11#include <linux/device.h>
12#include <linux/dev_printk.h>
13#include <linux/dmi.h>
14#include <linux/firmware.h>
15#include <linux/module.h>
16#include <linux/pci.h>
17#include <linux/pm_runtime.h>
18#include <linux/regmap.h>
19#include <linux/sprintf.h>
20#include <linux/soundwire/sdw.h>
21#include <linux/soundwire/sdw_registers.h>
22#include <sound/sdca.h>
23#include <sound/sdca_fdl.h>
24#include <sound/sdca_function.h>
25#include <sound/sdca_interrupts.h>
26#include <sound/sdca_ump.h>
27
28/**
29 * sdca_reset_function - send an SDCA function reset
30 * @dev: Device pointer for error messages.
31 * @function: Pointer to the SDCA Function.
32 * @regmap: Pointer to the SDCA Function regmap.
33 *
34 * Return: Zero on success or a negative error code.
35 */
36int sdca_reset_function(struct device *dev, struct sdca_function_data *function,
37 struct regmap *regmap)
38{
39 unsigned int reg = SDW_SDCA_CTL(function->desc->adr,
40 SDCA_ENTITY_TYPE_ENTITY_0,
41 SDCA_CTL_ENTITY_0_FUNCTION_ACTION, 0);
42 unsigned int val, poll_us;
43 int ret;
44
45 ret = regmap_write(map: regmap, reg, val: SDCA_CTL_ENTITY_0_RESET_FUNCTION_NOW);
46 if (ret) // Allowed for function reset to not be implemented
47 return 0;
48
49 if (!function->reset_max_delay) {
50 dev_err(dev, "No reset delay specified in DisCo\n");
51 return -EINVAL;
52 }
53
54 /*
55 * Poll up to 16 times but no more than once per ms, these are just
56 * arbitrarily selected values, so may be fine tuned in future.
57 */
58 poll_us = umin(function->reset_max_delay >> 4, 1000);
59
60 ret = regmap_read_poll_timeout(regmap, reg, val, !val, poll_us,
61 function->reset_max_delay);
62 if (ret) {
63 dev_err(dev, "Failed waiting for function reset: %d\n", ret);
64 return ret;
65 }
66
67 return 0;
68}
69EXPORT_SYMBOL_NS(sdca_reset_function, "SND_SOC_SDCA");
70
71/**
72 * sdca_fdl_sync - wait for a function to finish FDL
73 * @dev: Device pointer for error messages.
74 * @function: Pointer to the SDCA Function.
75 * @info: Pointer to the SDCA interrupt info for this device.
76 *
77 * Return: Zero on success or a negative error code.
78 */
79int sdca_fdl_sync(struct device *dev, struct sdca_function_data *function,
80 struct sdca_interrupt_info *info)
81{
82 static const int fdl_retries = 6;
83 unsigned long begin_timeout = msecs_to_jiffies(m: 100);
84 unsigned long done_timeout = msecs_to_jiffies(m: 4000);
85 int nfdl;
86 int i, j;
87
88 for (i = 0; i < fdl_retries; i++) {
89 nfdl = 0;
90
91 for (j = 0; j < SDCA_MAX_INTERRUPTS; j++) {
92 struct sdca_interrupt *interrupt = &info->irqs[j];
93 struct fdl_state *fdl_state;
94 unsigned long time;
95
96 if (interrupt->function != function ||
97 !interrupt->entity || !interrupt->control ||
98 interrupt->entity->type != SDCA_ENTITY_TYPE_XU ||
99 interrupt->control->sel != SDCA_CTL_XU_FDL_CURRENTOWNER)
100 continue;
101
102 fdl_state = interrupt->priv;
103 nfdl++;
104
105 /*
106 * Looking for timeout without any new FDL requests
107 * to imply the device has completed initial
108 * firmware setup. Alas the specification doesn't
109 * have any mechanism to detect this.
110 */
111 time = wait_for_completion_timeout(x: &fdl_state->begin,
112 timeout: begin_timeout);
113 if (!time) {
114 dev_dbg(dev, "no new FDL starts\n");
115 nfdl--;
116 continue;
117 }
118
119 time = wait_for_completion_timeout(x: &fdl_state->done,
120 timeout: done_timeout);
121 if (!time) {
122 dev_err(dev, "timed out waiting for FDL to complete\n");
123 goto error;
124 }
125 }
126
127 if (!nfdl)
128 return 0;
129 }
130
131 dev_err(dev, "too many FDL requests\n");
132
133error:
134 for (j = 0; j < SDCA_MAX_INTERRUPTS; j++) {
135 struct sdca_interrupt *interrupt = &info->irqs[j];
136 struct fdl_state *fdl_state;
137
138 if (interrupt->function != function ||
139 !interrupt->entity || !interrupt->control ||
140 interrupt->entity->type != SDCA_ENTITY_TYPE_XU ||
141 interrupt->control->sel != SDCA_CTL_XU_FDL_CURRENTOWNER)
142 continue;
143
144 disable_irq(irq: interrupt->irq);
145
146 fdl_state = interrupt->priv;
147
148 sdca_ump_cancel_timeout(work: &fdl_state->timeout);
149 }
150
151 return -ETIMEDOUT;
152}
153EXPORT_SYMBOL_NS_GPL(sdca_fdl_sync, "SND_SOC_SDCA");
154
155static char *fdl_get_sku_filename(struct device *dev,
156 struct sdca_fdl_file *fdl_file)
157{
158 struct device *parent = dev;
159 const char *product_vendor;
160 const char *product_sku;
161
162 /*
163 * Try to find pci_dev manually because the card may not be ready to be
164 * used for snd_soc_card_get_pci_ssid yet
165 */
166 while (parent) {
167 if (dev_is_pci(parent)) {
168 struct pci_dev *pci_dev = to_pci_dev(parent);
169
170 return kasprintf(GFP_KERNEL, fmt: "sdca/%x/%x/%x/%x.bin",
171 fdl_file->vendor_id,
172 pci_dev->subsystem_vendor,
173 pci_dev->subsystem_device,
174 fdl_file->file_id);
175 } else {
176 parent = parent->parent;
177 }
178 }
179
180 product_vendor = dmi_get_system_info(field: DMI_SYS_VENDOR);
181 if (!product_vendor || !strcmp(product_vendor, "Default string"))
182 product_vendor = dmi_get_system_info(field: DMI_BOARD_VENDOR);
183 if (!product_vendor || !strcmp(product_vendor, "Default string"))
184 product_vendor = dmi_get_system_info(field: DMI_CHASSIS_VENDOR);
185 if (!product_vendor)
186 product_vendor = "unknown";
187
188 product_sku = dmi_get_system_info(field: DMI_PRODUCT_SKU);
189 if (!product_sku || !strcmp(product_sku, "Default string"))
190 product_sku = dmi_get_system_info(field: DMI_PRODUCT_NAME);
191 if (!product_sku)
192 product_sku = "unknown";
193
194 return kasprintf(GFP_KERNEL, fmt: "sdca/%x/%s/%s/%x.bin", fdl_file->vendor_id,
195 product_vendor, product_sku, fdl_file->file_id);
196}
197
198static int fdl_load_file(struct sdca_interrupt *interrupt,
199 struct sdca_fdl_set *set, int file_index)
200{
201 struct device *dev = interrupt->dev;
202 struct sdca_fdl_data *fdl_data = &interrupt->function->fdl_data;
203 const struct firmware *firmware = NULL;
204 struct acpi_sw_file *swf = NULL, *tmp;
205 struct sdca_fdl_file *fdl_file;
206 char *disk_filename;
207 int ret;
208 int i;
209
210 if (!set) {
211 dev_err(dev, "request to load SWF with no set\n");
212 return -EINVAL;
213 }
214
215 fdl_file = &set->files[file_index];
216
217 if (fdl_data->swft) {
218 tmp = fdl_data->swft->files;
219 for (i = 0; i < fdl_data->swft->header.length; i += tmp->file_length,
220 tmp = ACPI_ADD_PTR(struct acpi_sw_file, tmp, tmp->file_length)) {
221 if (tmp->vendor_id == fdl_file->vendor_id &&
222 tmp->file_id == fdl_file->file_id) {
223 dev_dbg(dev, "located SWF in ACPI: %x-%x-%x\n",
224 tmp->vendor_id, tmp->file_id,
225 tmp->file_version);
226 swf = tmp;
227 break;
228 }
229 }
230 }
231
232 disk_filename = fdl_get_sku_filename(dev, fdl_file);
233 if (!disk_filename)
234 return -ENOMEM;
235
236 dev_dbg(dev, "FDL disk filename: %s\n", disk_filename);
237
238 ret = firmware_request_nowarn(fw: &firmware, name: disk_filename, device: dev);
239 kfree(objp: disk_filename);
240 if (ret) {
241 disk_filename = kasprintf(GFP_KERNEL, fmt: "sdca/%x/%x.bin",
242 fdl_file->vendor_id, fdl_file->file_id);
243 if (!disk_filename)
244 return -ENOMEM;
245
246 dev_dbg(dev, "FDL disk filename: %s\n", disk_filename);
247
248 ret = firmware_request_nowarn(fw: &firmware, name: disk_filename, device: dev);
249 kfree(objp: disk_filename);
250 }
251
252 if (!ret) {
253 tmp = (struct acpi_sw_file *)&firmware->data[0];
254
255 if (firmware->size < sizeof(*tmp) ||
256 tmp->file_length != firmware->size) {
257 dev_err(dev, "bad disk SWF size\n");
258 } else if (!swf || swf->file_version <= tmp->file_version) {
259 dev_dbg(dev, "using SWF from disk: %x-%x-%x\n",
260 tmp->vendor_id, tmp->file_id, tmp->file_version);
261 swf = tmp;
262 }
263 }
264
265 if (!swf) {
266 dev_err(dev, "failed to locate SWF\n");
267 return -ENOENT;
268 }
269
270 ret = sdca_ump_write_message(dev, device_regmap: interrupt->device_regmap,
271 function_regmap: interrupt->function_regmap,
272 function: interrupt->function, entity: interrupt->entity,
273 offset_sel: SDCA_CTL_XU_FDL_MESSAGEOFFSET, msg_offset: fdl_file->fdl_offset,
274 length_sel: SDCA_CTL_XU_FDL_MESSAGELENGTH, msg: swf->data,
275 msg_len: swf->file_length - offsetof(struct acpi_sw_file, data));
276 release_firmware(fw: firmware);
277 return ret;
278}
279
280static struct sdca_fdl_set *fdl_get_set(struct sdca_interrupt *interrupt)
281{
282 struct device *dev = interrupt->dev;
283 struct sdca_fdl_data *fdl_data = &interrupt->function->fdl_data;
284 struct sdca_entity *xu = interrupt->entity;
285 struct sdca_control_range *range;
286 unsigned int val;
287 int i, ret;
288
289 ret = regmap_read(map: interrupt->function_regmap,
290 SDW_SDCA_CTL(interrupt->function->desc->adr, xu->id,
291 SDCA_CTL_XU_FDL_SET_INDEX, 0),
292 val: &val);
293 if (ret < 0) {
294 dev_err(dev, "failed to read FDL set index: %d\n", ret);
295 return NULL;
296 }
297
298 range = sdca_selector_find_range(dev, entity: xu, sel: SDCA_CTL_XU_FDL_SET_INDEX,
299 cols: SDCA_FDL_SET_INDEX_NCOLS, rows: 0);
300
301 val = sdca_range_search(range, search_col: SDCA_FDL_SET_INDEX_SET_NUMBER,
302 value: val, result_col: SDCA_FDL_SET_INDEX_FILE_SET_ID);
303
304 for (i = 0; i < fdl_data->num_sets; i++) {
305 if (fdl_data->sets[i].id == val)
306 return &fdl_data->sets[i];
307 }
308
309 dev_err(dev, "invalid fileset id: %d\n", val);
310 return NULL;
311}
312
313static void fdl_end(struct sdca_interrupt *interrupt)
314{
315 struct fdl_state *fdl_state = interrupt->priv;
316
317 if (!fdl_state->set)
318 return;
319
320 fdl_state->set = NULL;
321
322 pm_runtime_put(dev: interrupt->dev);
323 complete(&fdl_state->done);
324
325 dev_dbg(interrupt->dev, "completed FDL process\n");
326}
327
328static void sdca_fdl_timeout_work(struct work_struct *work)
329{
330 struct fdl_state *fdl_state = container_of(work, struct fdl_state,
331 timeout.work);
332 struct sdca_interrupt *interrupt = fdl_state->interrupt;
333 struct device *dev = interrupt->dev;
334
335 dev_err(dev, "FDL transaction timed out\n");
336
337 guard(mutex)(T: &fdl_state->lock);
338
339 fdl_end(interrupt);
340 sdca_reset_function(dev, interrupt->function, interrupt->function_regmap);
341}
342
343static int fdl_status_process(struct sdca_interrupt *interrupt, unsigned int status)
344{
345 struct fdl_state *fdl_state = interrupt->priv;
346 int ret;
347
348 switch (status) {
349 case SDCA_CTL_XU_FDLD_NEEDS_SET:
350 dev_dbg(interrupt->dev, "starting FDL process...\n");
351
352 pm_runtime_get(dev: interrupt->dev);
353 complete(&fdl_state->begin);
354
355 fdl_state->file_index = 0;
356 fdl_state->set = fdl_get_set(interrupt);
357 fallthrough;
358 case SDCA_CTL_XU_FDLD_MORE_FILES_OK:
359 ret = fdl_load_file(interrupt, set: fdl_state->set, file_index: fdl_state->file_index);
360 if (ret) {
361 fdl_end(interrupt);
362 return SDCA_CTL_XU_FDLH_REQ_ABORT;
363 }
364
365 return SDCA_CTL_XU_FDLH_FILE_AVAILABLE;
366 case SDCA_CTL_XU_FDLD_FILE_OK:
367 if (!fdl_state->set) {
368 fdl_end(interrupt);
369 return SDCA_CTL_XU_FDLH_REQ_ABORT;
370 }
371
372 fdl_state->file_index++;
373
374 if (fdl_state->file_index < fdl_state->set->num_files)
375 return SDCA_CTL_XU_FDLH_MORE_FILES;
376 fallthrough;
377 case SDCA_CTL_XU_FDLD_COMPLETE:
378 fdl_end(interrupt);
379 return SDCA_CTL_XU_FDLH_COMPLETE;
380 default:
381 fdl_end(interrupt);
382
383 if (status & SDCA_CTL_XU_FDLD_REQ_RESET)
384 return SDCA_CTL_XU_FDLH_RESET_ACK;
385 else if (status & SDCA_CTL_XU_FDLD_REQ_ABORT)
386 return SDCA_CTL_XU_FDLH_COMPLETE;
387
388 dev_err(interrupt->dev, "invalid FDL status: %x\n", status);
389 return -EINVAL;
390 }
391}
392
393/**
394 * sdca_fdl_process - Process the FDL state machine
395 * @interrupt: SDCA interrupt structure
396 *
397 * Based on section 13.2.5 Flow Diagram for File Download, Host side.
398 *
399 * Return: Zero on success or a negative error code.
400 */
401int sdca_fdl_process(struct sdca_interrupt *interrupt)
402{
403 struct device *dev = interrupt->dev;
404 struct sdca_entity_xu *xu = &interrupt->entity->xu;
405 struct fdl_state *fdl_state = interrupt->priv;
406 unsigned int reg, status;
407 int response, ret;
408
409 ret = sdca_ump_get_owner_host(dev, function_regmap: interrupt->function_regmap,
410 function: interrupt->function, entity: interrupt->entity,
411 control: interrupt->control);
412 if (ret)
413 goto reset_function;
414
415 sdca_ump_cancel_timeout(work: &fdl_state->timeout);
416
417 scoped_guard(mutex, &fdl_state->lock) {
418 reg = SDW_SDCA_CTL(interrupt->function->desc->adr,
419 interrupt->entity->id, SDCA_CTL_XU_FDL_STATUS, 0);
420 ret = regmap_read(map: interrupt->function_regmap, reg, val: &status);
421 if (ret < 0) {
422 dev_err(dev, "failed to read FDL status: %d\n", ret);
423 return ret;
424 }
425
426 dev_dbg(dev, "FDL status: %#x\n", status);
427
428 ret = fdl_status_process(interrupt, status);
429 if (ret < 0)
430 goto reset_function;
431
432 response = ret;
433
434 dev_dbg(dev, "FDL response: %#x\n", response);
435
436 ret = regmap_write(map: interrupt->function_regmap, reg,
437 val: response | (status & ~SDCA_CTL_XU_FDLH_MASK));
438 if (ret < 0) {
439 dev_err(dev, "failed to set FDL status signal: %d\n", ret);
440 return ret;
441 }
442
443 ret = sdca_ump_set_owner_device(dev, function_regmap: interrupt->function_regmap,
444 function: interrupt->function,
445 entity: interrupt->entity,
446 control: interrupt->control);
447 if (ret)
448 return ret;
449
450 switch (response) {
451 case SDCA_CTL_XU_FDLH_RESET_ACK:
452 dev_dbg(dev, "FDL request reset\n");
453
454 switch (xu->reset_mechanism) {
455 default:
456 dev_warn(dev, "Requested reset mechanism not implemented\n");
457 fallthrough;
458 case SDCA_XU_RESET_FUNCTION:
459 goto reset_function;
460 }
461 case SDCA_CTL_XU_FDLH_COMPLETE:
462 if (status & SDCA_CTL_XU_FDLD_REQ_ABORT ||
463 status == SDCA_CTL_XU_FDLD_COMPLETE)
464 return 0;
465 fallthrough;
466 default:
467 sdca_ump_schedule_timeout(work: &fdl_state->timeout, timeout_us: xu->max_delay);
468 return 0;
469 }
470 }
471
472reset_function:
473 sdca_reset_function(dev, interrupt->function, interrupt->function_regmap);
474
475 return ret;
476}
477EXPORT_SYMBOL_NS_GPL(sdca_fdl_process, "SND_SOC_SDCA");
478
479/**
480 * sdca_fdl_alloc_state - allocate state for an FDL interrupt
481 * @interrupt: SDCA interrupt structure.
482 *
483 * Return: Zero on success or a negative error code.
484 */
485int sdca_fdl_alloc_state(struct sdca_interrupt *interrupt)
486{
487 struct device *dev = interrupt->dev;
488 struct fdl_state *fdl_state;
489
490 fdl_state = devm_kzalloc(dev, size: sizeof(struct fdl_state), GFP_KERNEL);
491 if (!fdl_state)
492 return -ENOMEM;
493
494 INIT_DELAYED_WORK(&fdl_state->timeout, sdca_fdl_timeout_work);
495 init_completion(x: &fdl_state->begin);
496 init_completion(x: &fdl_state->done);
497 mutex_init(&fdl_state->lock);
498 fdl_state->interrupt = interrupt;
499
500 interrupt->priv = fdl_state;
501
502 return 0;
503}
504EXPORT_SYMBOL_NS_GPL(sdca_fdl_alloc_state, "SND_SOC_SDCA");
505

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