Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2//
3// Copyright(c) 2021-2022 Intel Corporation
4//
5// Authors: Cezary Rojewski <cezary.rojewski@intel.com>
6// Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>
7//
8
9#include <linux/slab.h>
10#include "avs.h"
11#include "messages.h"
12
13#define AVS_CL_TIMEOUT_MS 5000
14
15int avs_ipc_set_boot_config(struct avs_dev *adev, u32 dma_id, u32 purge)
16{
17 union avs_global_msg msg = AVS_GLOBAL_REQUEST(ROM_CONTROL);
18 struct avs_ipc_msg request = {{0}};
19
20 msg.boot_cfg.rom_ctrl_msg_type = AVS_ROM_SET_BOOT_CONFIG;
21 msg.boot_cfg.dma_id = dma_id;
22 msg.boot_cfg.purge_request = purge;
23 request.header = msg.val;
24
25 return avs_dsp_send_rom_msg(adev, &request, "set boot config");
26}
27
28int avs_ipc_load_modules(struct avs_dev *adev, u16 *mod_ids, u32 num_mod_ids)
29{
30 union avs_global_msg msg = AVS_GLOBAL_REQUEST(LOAD_MULTIPLE_MODULES);
31 struct avs_ipc_msg request;
32
33 msg.load_multi_mods.mod_cnt = num_mod_ids;
34 request.header = msg.val;
35 request.data = mod_ids;
36 request.size = sizeof(*mod_ids) * num_mod_ids;
37
38 return avs_dsp_send_msg_timeout(adev, &request, NULL, AVS_CL_TIMEOUT_MS,
39 "load multiple modules");
40}
41
42int avs_ipc_unload_modules(struct avs_dev *adev, u16 *mod_ids, u32 num_mod_ids)
43{
44 union avs_global_msg msg = AVS_GLOBAL_REQUEST(UNLOAD_MULTIPLE_MODULES);
45 struct avs_ipc_msg request;
46
47 msg.load_multi_mods.mod_cnt = num_mod_ids;
48 request.header = msg.val;
49 request.data = mod_ids;
50 request.size = sizeof(*mod_ids) * num_mod_ids;
51
52 return avs_dsp_send_msg(adev, &request, NULL, "unload multiple modules");
53}
54
55int avs_ipc_load_library(struct avs_dev *adev, u32 dma_id, u32 lib_id)
56{
57 union avs_global_msg msg = AVS_GLOBAL_REQUEST(LOAD_LIBRARY);
58 struct avs_ipc_msg request = {{0}};
59
60 msg.load_lib.dma_id = dma_id;
61 msg.load_lib.lib_id = lib_id;
62 request.header = msg.val;
63
64 return avs_dsp_send_msg_timeout(adev, &request, NULL, AVS_CL_TIMEOUT_MS, "load library");
65}
66
67int avs_ipc_create_pipeline(struct avs_dev *adev, u16 req_size, u8 priority,
68 u8 instance_id, bool lp, u16 attributes)
69{
70 union avs_global_msg msg = AVS_GLOBAL_REQUEST(CREATE_PIPELINE);
71 struct avs_ipc_msg request = {{0}};
72
73 msg.create_ppl.ppl_mem_size = req_size;
74 msg.create_ppl.ppl_priority = priority;
75 msg.create_ppl.instance_id = instance_id;
76 msg.ext.create_ppl.lp = lp;
77 msg.ext.create_ppl.attributes = attributes;
78 request.header = msg.val;
79
80 return avs_dsp_send_msg(adev, &request, NULL, "create pipeline");
81}
82
83int avs_ipc_delete_pipeline(struct avs_dev *adev, u8 instance_id)
84{
85 union avs_global_msg msg = AVS_GLOBAL_REQUEST(DELETE_PIPELINE);
86 struct avs_ipc_msg request = {{0}};
87
88 msg.ppl.instance_id = instance_id;
89 request.header = msg.val;
90
91 return avs_dsp_send_msg(adev, &request, NULL, "delete pipeline");
92}
93
94int avs_ipc_set_pipeline_state(struct avs_dev *adev, u8 instance_id,
95 enum avs_pipeline_state state)
96{
97 union avs_global_msg msg = AVS_GLOBAL_REQUEST(SET_PIPELINE_STATE);
98 struct avs_ipc_msg request = {{0}};
99
100 msg.set_ppl_state.ppl_id = instance_id;
101 msg.set_ppl_state.state = state;
102 request.header = msg.val;
103
104 return avs_dsp_send_msg(adev, &request, NULL, "set pipeline state");
105}
106
107int avs_ipc_get_pipeline_state(struct avs_dev *adev, u8 instance_id,
108 enum avs_pipeline_state *state)
109{
110 union avs_global_msg msg = AVS_GLOBAL_REQUEST(GET_PIPELINE_STATE);
111 struct avs_ipc_msg request = {{0}};
112 struct avs_ipc_msg reply = {{0}};
113 int ret;
114
115 msg.get_ppl_state.ppl_id = instance_id;
116 request.header = msg.val;
117
118 ret = avs_dsp_send_msg(adev, &request, &reply, "get pipeline state");
119 if (!ret)
120 *state = reply.rsp.ext.get_ppl_state.state;
121 return ret;
122}
123
124/*
125 * avs_ipc_init_instance - Initialize module instance
126 *
127 * @adev: Driver context
128 * @module_id: Module-type id
129 * @instance_id: Unique module instance id
130 * @ppl_id: Parent pipeline id
131 * @core_id: DSP core to allocate module on
132 * @domain: Processing domain (low latency or data processing)
133 * @param: Module-type specific configuration
134 * @param_size: Size of @param in bytes
135 *
136 * Argument verification, as well as pipeline state checks are done by the
137 * firmware.
138 *
139 * Note: @ppl_id and @core_id are independent of each other as single pipeline
140 * can be composed of module instances located on different DSP cores.
141 */
142int avs_ipc_init_instance(struct avs_dev *adev, u16 module_id, u8 instance_id,
143 u8 ppl_id, u8 core_id, u8 domain,
144 void *param, u32 param_size)
145{
146 union avs_module_msg msg = AVS_MODULE_REQUEST(INIT_INSTANCE);
147 struct avs_ipc_msg request;
148
149 msg.module_id = module_id;
150 msg.instance_id = instance_id;
151 /* firmware expects size provided in dwords */
152 msg.ext.init_instance.param_block_size = DIV_ROUND_UP(param_size, sizeof(u32));
153 msg.ext.init_instance.ppl_instance_id = ppl_id;
154 msg.ext.init_instance.core_id = core_id;
155 msg.ext.init_instance.proc_domain = domain;
156
157 request.header = msg.val;
158 request.data = param;
159 request.size = param_size;
160
161 return avs_dsp_send_msg(adev, &request, NULL, "init instance");
162}
163
164/*
165 * avs_ipc_delete_instance - Delete module instance
166 *
167 * @adev: Driver context
168 * @module_id: Module-type id
169 * @instance_id: Unique module instance id
170 *
171 * Argument verification, as well as pipeline state checks are done by the
172 * firmware.
173 *
174 * Note: only standalone modules i.e. without a parent pipeline shall be
175 * deleted using this IPC message. In all other cases, pipeline owning the
176 * modules performs cleanup automatically when it is deleted.
177 */
178int avs_ipc_delete_instance(struct avs_dev *adev, u16 module_id, u8 instance_id)
179{
180 union avs_module_msg msg = AVS_MODULE_REQUEST(DELETE_INSTANCE);
181 struct avs_ipc_msg request = {{0}};
182
183 msg.module_id = module_id;
184 msg.instance_id = instance_id;
185 request.header = msg.val;
186
187 return avs_dsp_send_msg(adev, &request, NULL, "delete instance");
188}
189
190/*
191 * avs_ipc_bind - Bind two module instances
192 *
193 * @adev: Driver context
194 * @module_id: Source module-type id
195 * @instance_id: Source module instance id
196 * @dst_module_id: Sink module-type id
197 * @dst_instance_id: Sink module instance id
198 * @dst_queue: Sink module pin to bind @src_queue with
199 * @src_queue: Source module pin to bind @dst_queue with
200 */
201int avs_ipc_bind(struct avs_dev *adev, u16 module_id, u8 instance_id,
202 u16 dst_module_id, u8 dst_instance_id,
203 u8 dst_queue, u8 src_queue)
204{
205 union avs_module_msg msg = AVS_MODULE_REQUEST(BIND);
206 struct avs_ipc_msg request = {{0}};
207
208 msg.module_id = module_id;
209 msg.instance_id = instance_id;
210 msg.ext.bind_unbind.dst_module_id = dst_module_id;
211 msg.ext.bind_unbind.dst_instance_id = dst_instance_id;
212 msg.ext.bind_unbind.dst_queue = dst_queue;
213 msg.ext.bind_unbind.src_queue = src_queue;
214 request.header = msg.val;
215
216 return avs_dsp_send_msg(adev, &request, NULL, "bind modules");
217}
218
219/*
220 * avs_ipc_unbind - Unbind two module instances
221 *
222 * @adev: Driver context
223 * @module_id: Source module-type id
224 * @instance_id: Source module instance id
225 * @dst_module_id: Sink module-type id
226 * @dst_instance_id: Sink module instance id
227 * @dst_queue: Sink module pin to unbind @src_queue from
228 * @src_queue: Source module pin to unbind @dst_queue from
229 */
230int avs_ipc_unbind(struct avs_dev *adev, u16 module_id, u8 instance_id,
231 u16 dst_module_id, u8 dst_instance_id,
232 u8 dst_queue, u8 src_queue)
233{
234 union avs_module_msg msg = AVS_MODULE_REQUEST(UNBIND);
235 struct avs_ipc_msg request = {{0}};
236
237 msg.module_id = module_id;
238 msg.instance_id = instance_id;
239 msg.ext.bind_unbind.dst_module_id = dst_module_id;
240 msg.ext.bind_unbind.dst_instance_id = dst_instance_id;
241 msg.ext.bind_unbind.dst_queue = dst_queue;
242 msg.ext.bind_unbind.src_queue = src_queue;
243 request.header = msg.val;
244
245 return avs_dsp_send_msg(adev, &request, NULL, "unbind modules");
246}
247
248static int __avs_ipc_set_large_config(struct avs_dev *adev, u16 module_id, u8 instance_id,
249 u8 param_id, bool init_block, bool final_block,
250 u8 *request_data, size_t request_size, size_t off_size)
251{
252 union avs_module_msg msg = AVS_MODULE_REQUEST(LARGE_CONFIG_SET);
253 struct avs_ipc_msg request;
254
255 msg.module_id = module_id;
256 msg.instance_id = instance_id;
257 msg.ext.large_config.data_off_size = off_size;
258 msg.ext.large_config.large_param_id = param_id;
259 msg.ext.large_config.final_block = final_block;
260 msg.ext.large_config.init_block = init_block;
261
262 request.header = msg.val;
263 request.data = request_data;
264 request.size = request_size;
265
266 return avs_dsp_send_msg(adev, &request, NULL, "large config set");
267}
268
269int avs_ipc_set_large_config(struct avs_dev *adev, u16 module_id,
270 u8 instance_id, u8 param_id,
271 u8 *request, size_t request_size)
272{
273 size_t remaining, tx_size;
274 bool final;
275 int ret;
276
277 remaining = request_size;
278 tx_size = min_t(size_t, AVS_MAILBOX_SIZE, remaining);
279 final = (tx_size == remaining);
280
281 /* Initial request states total payload size. */
282 ret = __avs_ipc_set_large_config(adev, module_id, instance_id,
283 param_id, 1, final, request, tx_size,
284 request_size);
285 if (ret)
286 return ret;
287
288 remaining -= tx_size;
289
290 /* Loop the rest only when payload exceeds mailbox's size. */
291 while (remaining) {
292 size_t offset;
293
294 offset = request_size - remaining;
295 tx_size = min_t(size_t, AVS_MAILBOX_SIZE, remaining);
296 final = (tx_size == remaining);
297
298 ret = __avs_ipc_set_large_config(adev, module_id, instance_id,
299 param_id, 0, final,
300 request + offset, tx_size,
301 offset);
302 if (ret)
303 return ret;
304
305 remaining -= tx_size;
306 }
307
308 return 0;
309}
310
311int avs_ipc_get_large_config(struct avs_dev *adev, u16 module_id, u8 instance_id,
312 u8 param_id, u8 *request_data, size_t request_size,
313 u8 **reply_data, size_t *reply_size)
314{
315 union avs_module_msg msg = AVS_MODULE_REQUEST(LARGE_CONFIG_GET);
316 struct avs_ipc_msg request;
317 struct avs_ipc_msg reply = {{0}};
318 void *buf;
319 int ret;
320
321 reply.data = kzalloc(AVS_MAILBOX_SIZE, GFP_KERNEL);
322 if (!reply.data)
323 return -ENOMEM;
324
325 msg.module_id = module_id;
326 msg.instance_id = instance_id;
327 msg.ext.large_config.data_off_size = request_size;
328 msg.ext.large_config.large_param_id = param_id;
329 /* final_block is always 0 on request. Updated by fw on reply. */
330 msg.ext.large_config.final_block = 0;
331 msg.ext.large_config.init_block = 1;
332
333 request.header = msg.val;
334 request.data = request_data;
335 request.size = request_size;
336 reply.size = AVS_MAILBOX_SIZE;
337
338 ret = avs_dsp_send_msg(adev, &request, &reply, "large config get");
339 if (ret) {
340 kfree(reply.data);
341 return ret;
342 }
343
344 buf = krealloc(reply.data, reply.size, GFP_KERNEL);
345 if (!buf) {
346 kfree(reply.data);
347 return -ENOMEM;
348 }
349
350 *reply_data = buf;
351 *reply_size = reply.size;
352
353 return 0;
354}
355
356int avs_ipc_set_dx(struct avs_dev *adev, u32 core_mask, bool powerup)
357{
358 union avs_module_msg msg = AVS_MODULE_REQUEST(SET_DX);
359 struct avs_ipc_msg request;
360 struct avs_dxstate_info dx;
361
362 dx.core_mask = core_mask;
363 dx.dx_mask = powerup ? core_mask : 0;
364 request.header = msg.val;
365 request.data = &dx;
366 request.size = sizeof(dx);
367
368 return avs_dsp_send_pm_msg(adev, &request, NULL, true, "set dx");
369}
370
371/*
372 * avs_ipc_set_d0ix - Set power gating policy (entering D0IX substates)
373 *
374 * @enable_pg: Whether to enable or disable power gating
375 * @streaming: Whether a stream is running when transitioning
376 */
377int avs_ipc_set_d0ix(struct avs_dev *adev, bool enable_pg, bool streaming)
378{
379 union avs_module_msg msg = AVS_MODULE_REQUEST(SET_D0IX);
380 struct avs_ipc_msg request = {{0}};
381
382 msg.ext.set_d0ix.wake = enable_pg;
383 msg.ext.set_d0ix.streaming = streaming;
384 msg.ext.set_d0ix.prevent_pg = !enable_pg;
385
386 request.header = msg.val;
387
388 return avs_dsp_send_pm_msg(adev, &request, NULL, false, "set d0ix");
389}
390
391int avs_ipc_get_fw_config(struct avs_dev *adev, struct avs_fw_cfg *cfg)
392{
393 struct avs_tlv *tlv;
394 size_t payload_size;
395 size_t offset = 0;
396 u8 *payload;
397 int ret;
398
399 ret = avs_ipc_get_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
400 AVS_BASEFW_FIRMWARE_CONFIG, NULL, 0,
401 &payload, &payload_size);
402 if (ret)
403 return ret;
404 /* Non-zero payload expected for FIRMWARE_CONFIG. */
405 if (!payload_size)
406 return -EREMOTEIO;
407
408 while (offset < payload_size) {
409 tlv = (struct avs_tlv *)(payload + offset);
410
411 switch (tlv->type) {
412 case AVS_FW_CFG_FW_VERSION:
413 memcpy(&cfg->fw_version, tlv->value, sizeof(cfg->fw_version));
414 break;
415
416 case AVS_FW_CFG_MEMORY_RECLAIMED:
417 cfg->memory_reclaimed = *tlv->value;
418 break;
419
420 case AVS_FW_CFG_SLOW_CLOCK_FREQ_HZ:
421 cfg->slow_clock_freq_hz = *tlv->value;
422 break;
423
424 case AVS_FW_CFG_FAST_CLOCK_FREQ_HZ:
425 cfg->fast_clock_freq_hz = *tlv->value;
426 break;
427
428 case AVS_FW_CFG_ALH_SUPPORT_LEVEL:
429 cfg->alh_support = *tlv->value;
430 break;
431
432 case AVS_FW_CFG_IPC_DL_MAILBOX_BYTES:
433 cfg->ipc_dl_mailbox_bytes = *tlv->value;
434 break;
435
436 case AVS_FW_CFG_IPC_UL_MAILBOX_BYTES:
437 cfg->ipc_ul_mailbox_bytes = *tlv->value;
438 break;
439
440 case AVS_FW_CFG_TRACE_LOG_BYTES:
441 cfg->trace_log_bytes = *tlv->value;
442 break;
443
444 case AVS_FW_CFG_MAX_PPL_COUNT:
445 cfg->max_ppl_count = *tlv->value;
446 break;
447
448 case AVS_FW_CFG_MAX_ASTATE_COUNT:
449 cfg->max_astate_count = *tlv->value;
450 break;
451
452 case AVS_FW_CFG_MAX_MODULE_PIN_COUNT:
453 cfg->max_module_pin_count = *tlv->value;
454 break;
455
456 case AVS_FW_CFG_MODULES_COUNT:
457 cfg->modules_count = *tlv->value;
458 break;
459
460 case AVS_FW_CFG_MAX_MOD_INST_COUNT:
461 cfg->max_mod_inst_count = *tlv->value;
462 break;
463
464 case AVS_FW_CFG_MAX_LL_TASKS_PER_PRI_COUNT:
465 cfg->max_ll_tasks_per_pri_count = *tlv->value;
466 break;
467
468 case AVS_FW_CFG_LL_PRI_COUNT:
469 cfg->ll_pri_count = *tlv->value;
470 break;
471
472 case AVS_FW_CFG_MAX_DP_TASKS_COUNT:
473 cfg->max_dp_tasks_count = *tlv->value;
474 break;
475
476 case AVS_FW_CFG_MAX_LIBS_COUNT:
477 cfg->max_libs_count = *tlv->value;
478 break;
479
480 case AVS_FW_CFG_XTAL_FREQ_HZ:
481 cfg->xtal_freq_hz = *tlv->value;
482 break;
483
484 case AVS_FW_CFG_POWER_GATING_POLICY:
485 cfg->power_gating_policy = *tlv->value;
486 break;
487
488 /* Known but not useful to us. */
489 case AVS_FW_CFG_DMA_BUFFER_CONFIG:
490 case AVS_FW_CFG_SCHEDULER_CONFIG:
491 case AVS_FW_CFG_CLOCKS_CONFIG:
492 case AVS_FW_CFG_RESERVED:
493 break;
494
495 default:
496 dev_info(adev->dev, "Unrecognized fw param: %d\n", tlv->type);
497 break;
498 }
499
500 offset += sizeof(*tlv) + tlv->length;
501 }
502
503 /* No longer needed, free it as it's owned by the get_large_config() caller. */
504 kfree(payload);
505 return ret;
506}
507
508int avs_ipc_get_hw_config(struct avs_dev *adev, struct avs_hw_cfg *cfg)
509{
510 struct avs_tlv *tlv;
511 size_t payload_size;
512 size_t size, offset = 0;
513 u8 *payload;
514 int ret;
515
516 ret = avs_ipc_get_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
517 AVS_BASEFW_HARDWARE_CONFIG, NULL, 0,
518 &payload, &payload_size);
519 if (ret)
520 return ret;
521 /* Non-zero payload expected for HARDWARE_CONFIG. */
522 if (!payload_size)
523 return -EREMOTEIO;
524
525 while (offset < payload_size) {
526 tlv = (struct avs_tlv *)(payload + offset);
527
528 switch (tlv->type) {
529 case AVS_HW_CFG_AVS_VER:
530 cfg->avs_version = *tlv->value;
531 break;
532
533 case AVS_HW_CFG_DSP_CORES:
534 cfg->dsp_cores = *tlv->value;
535 break;
536
537 case AVS_HW_CFG_MEM_PAGE_BYTES:
538 cfg->mem_page_bytes = *tlv->value;
539 break;
540
541 case AVS_HW_CFG_TOTAL_PHYS_MEM_PAGES:
542 cfg->total_phys_mem_pages = *tlv->value;
543 break;
544
545 case AVS_HW_CFG_I2S_CAPS:
546 cfg->i2s_caps.i2s_version = tlv->value[0];
547 size = tlv->value[1];
548 cfg->i2s_caps.ctrl_count = size;
549 if (!size)
550 break;
551
552 /* Multiply to get entire array size. */
553 size *= sizeof(*cfg->i2s_caps.ctrl_base_addr);
554 cfg->i2s_caps.ctrl_base_addr = devm_kmemdup(adev->dev,
555 &tlv->value[2],
556 size, GFP_KERNEL);
557 if (!cfg->i2s_caps.ctrl_base_addr) {
558 ret = -ENOMEM;
559 goto exit;
560 }
561 break;
562
563 case AVS_HW_CFG_GATEWAY_COUNT:
564 cfg->gateway_count = *tlv->value;
565 break;
566
567 case AVS_HW_CFG_HP_EBB_COUNT:
568 cfg->hp_ebb_count = *tlv->value;
569 break;
570
571 case AVS_HW_CFG_LP_EBB_COUNT:
572 cfg->lp_ebb_count = *tlv->value;
573 break;
574
575 case AVS_HW_CFG_EBB_SIZE_BYTES:
576 cfg->ebb_size_bytes = *tlv->value;
577 break;
578
579 case AVS_HW_CFG_GPDMA_CAPS:
580 break;
581
582 default:
583 dev_info(adev->dev, "Unrecognized hw config: %d\n", tlv->type);
584 break;
585 }
586
587 offset += sizeof(*tlv) + tlv->length;
588 }
589
590exit:
591 /* No longer needed, free it as it's owned by the get_large_config() caller. */
592 kfree(payload);
593 return ret;
594}
595
596int avs_ipc_get_modules_info(struct avs_dev *adev, struct avs_mods_info **info)
597{
598 size_t payload_size;
599 u8 *payload;
600 int ret;
601
602 ret = avs_ipc_get_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
603 AVS_BASEFW_MODULES_INFO, NULL, 0,
604 &payload, &payload_size);
605 if (ret)
606 return ret;
607 /* Non-zero payload expected for MODULES_INFO. */
608 if (!payload_size)
609 return -EREMOTEIO;
610
611 *info = (struct avs_mods_info *)payload;
612 return 0;
613}
614
615int avs_ipc_copier_set_sink_format(struct avs_dev *adev, u16 module_id,
616 u8 instance_id, u32 sink_id,
617 const struct avs_audio_format *src_fmt,
618 const struct avs_audio_format *sink_fmt)
619{
620 struct avs_copier_sink_format cpr_fmt;
621
622 cpr_fmt.sink_id = sink_id;
623 /* Firmware expects driver to resend copier's input format. */
624 cpr_fmt.src_fmt = *src_fmt;
625 cpr_fmt.sink_fmt = *sink_fmt;
626
627 return avs_ipc_set_large_config(adev, module_id, instance_id,
628 AVS_COPIER_SET_SINK_FORMAT,
629 (u8 *)&cpr_fmt, sizeof(cpr_fmt));
630}
631
632int avs_ipc_peakvol_set_volume(struct avs_dev *adev, u16 module_id, u8 instance_id,
633 struct avs_volume_cfg *vol)
634{
635 return avs_ipc_set_large_config(adev, module_id, instance_id, AVS_PEAKVOL_VOLUME, (u8 *)vol,
636 sizeof(*vol));
637}
638
639int avs_ipc_peakvol_get_volume(struct avs_dev *adev, u16 module_id, u8 instance_id,
640 struct avs_volume_cfg **vols, size_t *num_vols)
641{
642 size_t payload_size;
643 u8 *payload;
644 int ret;
645
646 ret = avs_ipc_get_large_config(adev, module_id, instance_id, AVS_PEAKVOL_VOLUME, NULL, 0,
647 &payload, &payload_size);
648 if (ret)
649 return ret;
650
651 /* Non-zero payload expected for PEAKVOL_VOLUME. */
652 if (!payload_size)
653 return -EREMOTEIO;
654
655 *vols = (struct avs_volume_cfg *)payload;
656 *num_vols = payload_size / sizeof(**vols);
657
658 return 0;
659}
660
661#ifdef CONFIG_DEBUG_FS
662int avs_ipc_set_enable_logs(struct avs_dev *adev, u8 *log_info, size_t size)
663{
664 return avs_ipc_set_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
665 AVS_BASEFW_ENABLE_LOGS, log_info, size);
666}
667
668int avs_ipc_set_system_time(struct avs_dev *adev)
669{
670 struct avs_sys_time sys_time;
671 u64 us;
672
673 /* firmware expects UTC time in micro seconds */
674 us = ktime_to_us(ktime_get());
675 sys_time.val_l = us & UINT_MAX;
676 sys_time.val_u = us >> 32;
677
678 return avs_ipc_set_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
679 AVS_BASEFW_SYSTEM_TIME, (u8 *)&sys_time, sizeof(sys_time));
680}
681
682int avs_ipc_probe_get_dma(struct avs_dev *adev, struct avs_probe_dma **dmas, size_t *num_dmas)
683{
684 size_t payload_size;
685 u32 module_id;
686 u8 *payload;
687 int ret;
688
689 module_id = avs_get_module_id(adev, &AVS_PROBE_MOD_UUID);
690
691 ret = avs_ipc_get_large_config(adev, module_id, AVS_PROBE_INST_ID, AVS_PROBE_INJECTION_DMA,
692 NULL, 0, &payload, &payload_size);
693 if (ret)
694 return ret;
695
696 *dmas = (struct avs_probe_dma *)payload;
697 *num_dmas = payload_size / sizeof(**dmas);
698
699 return 0;
700}
701
702int avs_ipc_probe_attach_dma(struct avs_dev *adev, struct avs_probe_dma *dmas, size_t num_dmas)
703{
704 u32 module_id = avs_get_module_id(adev, &AVS_PROBE_MOD_UUID);
705
706 return avs_ipc_set_large_config(adev, module_id, AVS_PROBE_INST_ID, AVS_PROBE_INJECTION_DMA,
707 (u8 *)dmas, array_size(sizeof(*dmas), num_dmas));
708}
709
710int avs_ipc_probe_detach_dma(struct avs_dev *adev, union avs_connector_node_id *node_ids,
711 size_t num_node_ids)
712{
713 u32 module_id = avs_get_module_id(adev, &AVS_PROBE_MOD_UUID);
714
715 return avs_ipc_set_large_config(adev, module_id, AVS_PROBE_INST_ID,
716 AVS_PROBE_INJECTION_DMA_DETACH, (u8 *)node_ids,
717 array_size(sizeof(*node_ids), num_node_ids));
718}
719
720int avs_ipc_probe_get_points(struct avs_dev *adev, struct avs_probe_point_desc **descs,
721 size_t *num_descs)
722{
723 size_t payload_size;
724 u32 module_id;
725 u8 *payload;
726 int ret;
727
728 module_id = avs_get_module_id(adev, &AVS_PROBE_MOD_UUID);
729
730 ret = avs_ipc_get_large_config(adev, module_id, AVS_PROBE_INST_ID, AVS_PROBE_POINTS, NULL,
731 0, &payload, &payload_size);
732 if (ret)
733 return ret;
734
735 *descs = (struct avs_probe_point_desc *)payload;
736 *num_descs = payload_size / sizeof(**descs);
737
738 return 0;
739}
740
741int avs_ipc_probe_connect_points(struct avs_dev *adev, struct avs_probe_point_desc *descs,
742 size_t num_descs)
743{
744 u32 module_id = avs_get_module_id(adev, &AVS_PROBE_MOD_UUID);
745
746 return avs_ipc_set_large_config(adev, module_id, AVS_PROBE_INST_ID, AVS_PROBE_POINTS,
747 (u8 *)descs, array_size(sizeof(*descs), num_descs));
748}
749
750int avs_ipc_probe_disconnect_points(struct avs_dev *adev, union avs_probe_point_id *ids,
751 size_t num_ids)
752{
753 u32 module_id = avs_get_module_id(adev, &AVS_PROBE_MOD_UUID);
754
755 return avs_ipc_set_large_config(adev, module_id, AVS_PROBE_INST_ID,
756 AVS_PROBE_POINTS_DISCONNECT, (u8 *)ids,
757 array_size(sizeof(*ids), num_ids));
758}
759#endif
1// SPDX-License-Identifier: GPL-2.0-only
2//
3// Copyright(c) 2021-2022 Intel Corporation. All rights reserved.
4//
5// Authors: Cezary Rojewski <cezary.rojewski@intel.com>
6// Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>
7//
8
9#include <linux/slab.h>
10#include "avs.h"
11#include "messages.h"
12
13#define AVS_CL_TIMEOUT_MS 5000
14
15int avs_ipc_set_boot_config(struct avs_dev *adev, u32 dma_id, u32 purge)
16{
17 union avs_global_msg msg = AVS_GLOBAL_REQUEST(ROM_CONTROL);
18 struct avs_ipc_msg request = {{0}};
19 int ret;
20
21 msg.boot_cfg.rom_ctrl_msg_type = AVS_ROM_SET_BOOT_CONFIG;
22 msg.boot_cfg.dma_id = dma_id;
23 msg.boot_cfg.purge_request = purge;
24 request.header = msg.val;
25
26 ret = avs_dsp_send_rom_msg(adev, &request);
27 if (ret)
28 avs_ipc_err(adev, &request, "set boot config", ret);
29
30 return ret;
31}
32
33int avs_ipc_load_modules(struct avs_dev *adev, u16 *mod_ids, u32 num_mod_ids)
34{
35 union avs_global_msg msg = AVS_GLOBAL_REQUEST(LOAD_MULTIPLE_MODULES);
36 struct avs_ipc_msg request;
37 int ret;
38
39 msg.load_multi_mods.mod_cnt = num_mod_ids;
40 request.header = msg.val;
41 request.data = mod_ids;
42 request.size = sizeof(*mod_ids) * num_mod_ids;
43
44 ret = avs_dsp_send_msg_timeout(adev, &request, NULL, AVS_CL_TIMEOUT_MS);
45 if (ret)
46 avs_ipc_err(adev, &request, "load multiple modules", ret);
47
48 return ret;
49}
50
51int avs_ipc_unload_modules(struct avs_dev *adev, u16 *mod_ids, u32 num_mod_ids)
52{
53 union avs_global_msg msg = AVS_GLOBAL_REQUEST(UNLOAD_MULTIPLE_MODULES);
54 struct avs_ipc_msg request;
55 int ret;
56
57 msg.load_multi_mods.mod_cnt = num_mod_ids;
58 request.header = msg.val;
59 request.data = mod_ids;
60 request.size = sizeof(*mod_ids) * num_mod_ids;
61
62 ret = avs_dsp_send_msg(adev, &request, NULL);
63 if (ret)
64 avs_ipc_err(adev, &request, "unload multiple modules", ret);
65
66 return ret;
67}
68
69int avs_ipc_load_library(struct avs_dev *adev, u32 dma_id, u32 lib_id)
70{
71 union avs_global_msg msg = AVS_GLOBAL_REQUEST(LOAD_LIBRARY);
72 struct avs_ipc_msg request = {{0}};
73 int ret;
74
75 msg.load_lib.dma_id = dma_id;
76 msg.load_lib.lib_id = lib_id;
77 request.header = msg.val;
78
79 ret = avs_dsp_send_msg_timeout(adev, &request, NULL, AVS_CL_TIMEOUT_MS);
80 if (ret)
81 avs_ipc_err(adev, &request, "load library", ret);
82
83 return ret;
84}
85
86int avs_ipc_create_pipeline(struct avs_dev *adev, u16 req_size, u8 priority,
87 u8 instance_id, bool lp, u16 attributes)
88{
89 union avs_global_msg msg = AVS_GLOBAL_REQUEST(CREATE_PIPELINE);
90 struct avs_ipc_msg request = {{0}};
91 int ret;
92
93 msg.create_ppl.ppl_mem_size = req_size;
94 msg.create_ppl.ppl_priority = priority;
95 msg.create_ppl.instance_id = instance_id;
96 msg.ext.create_ppl.lp = lp;
97 msg.ext.create_ppl.attributes = attributes;
98 request.header = msg.val;
99
100 ret = avs_dsp_send_msg(adev, &request, NULL);
101 if (ret)
102 avs_ipc_err(adev, &request, "create pipeline", ret);
103
104 return ret;
105}
106
107int avs_ipc_delete_pipeline(struct avs_dev *adev, u8 instance_id)
108{
109 union avs_global_msg msg = AVS_GLOBAL_REQUEST(DELETE_PIPELINE);
110 struct avs_ipc_msg request = {{0}};
111 int ret;
112
113 msg.ppl.instance_id = instance_id;
114 request.header = msg.val;
115
116 ret = avs_dsp_send_msg(adev, &request, NULL);
117 if (ret)
118 avs_ipc_err(adev, &request, "delete pipeline", ret);
119
120 return ret;
121}
122
123int avs_ipc_set_pipeline_state(struct avs_dev *adev, u8 instance_id,
124 enum avs_pipeline_state state)
125{
126 union avs_global_msg msg = AVS_GLOBAL_REQUEST(SET_PIPELINE_STATE);
127 struct avs_ipc_msg request = {{0}};
128 int ret;
129
130 msg.set_ppl_state.ppl_id = instance_id;
131 msg.set_ppl_state.state = state;
132 request.header = msg.val;
133
134 ret = avs_dsp_send_msg(adev, &request, NULL);
135 if (ret)
136 avs_ipc_err(adev, &request, "set pipeline state", ret);
137
138 return ret;
139}
140
141int avs_ipc_get_pipeline_state(struct avs_dev *adev, u8 instance_id,
142 enum avs_pipeline_state *state)
143{
144 union avs_global_msg msg = AVS_GLOBAL_REQUEST(GET_PIPELINE_STATE);
145 struct avs_ipc_msg request = {{0}};
146 struct avs_ipc_msg reply = {{0}};
147 int ret;
148
149 msg.get_ppl_state.ppl_id = instance_id;
150 request.header = msg.val;
151
152 ret = avs_dsp_send_msg(adev, &request, &reply);
153 if (ret) {
154 avs_ipc_err(adev, &request, "get pipeline state", ret);
155 return ret;
156 }
157
158 *state = reply.rsp.ext.get_ppl_state.state;
159 return ret;
160}
161
162/*
163 * avs_ipc_init_instance - Initialize module instance
164 *
165 * @adev: Driver context
166 * @module_id: Module-type id
167 * @instance_id: Unique module instance id
168 * @ppl_id: Parent pipeline id
169 * @core_id: DSP core to allocate module on
170 * @domain: Processing domain (low latency or data processing)
171 * @param: Module-type specific configuration
172 * @param_size: Size of @param in bytes
173 *
174 * Argument verification, as well as pipeline state checks are done by the
175 * firmware.
176 *
177 * Note: @ppl_id and @core_id are independent of each other as single pipeline
178 * can be composed of module instances located on different DSP cores.
179 */
180int avs_ipc_init_instance(struct avs_dev *adev, u16 module_id, u8 instance_id,
181 u8 ppl_id, u8 core_id, u8 domain,
182 void *param, u32 param_size)
183{
184 union avs_module_msg msg = AVS_MODULE_REQUEST(INIT_INSTANCE);
185 struct avs_ipc_msg request;
186 int ret;
187
188 msg.module_id = module_id;
189 msg.instance_id = instance_id;
190 /* firmware expects size provided in dwords */
191 msg.ext.init_instance.param_block_size = DIV_ROUND_UP(param_size, sizeof(u32));
192 msg.ext.init_instance.ppl_instance_id = ppl_id;
193 msg.ext.init_instance.core_id = core_id;
194 msg.ext.init_instance.proc_domain = domain;
195
196 request.header = msg.val;
197 request.data = param;
198 request.size = param_size;
199
200 ret = avs_dsp_send_msg(adev, &request, NULL);
201 if (ret)
202 avs_ipc_err(adev, &request, "init instance", ret);
203
204 return ret;
205}
206
207/*
208 * avs_ipc_delete_instance - Delete module instance
209 *
210 * @adev: Driver context
211 * @module_id: Module-type id
212 * @instance_id: Unique module instance id
213 *
214 * Argument verification, as well as pipeline state checks are done by the
215 * firmware.
216 *
217 * Note: only standalone modules i.e. without a parent pipeline shall be
218 * deleted using this IPC message. In all other cases, pipeline owning the
219 * modules performs cleanup automatically when it is deleted.
220 */
221int avs_ipc_delete_instance(struct avs_dev *adev, u16 module_id, u8 instance_id)
222{
223 union avs_module_msg msg = AVS_MODULE_REQUEST(DELETE_INSTANCE);
224 struct avs_ipc_msg request = {{0}};
225 int ret;
226
227 msg.module_id = module_id;
228 msg.instance_id = instance_id;
229 request.header = msg.val;
230
231 ret = avs_dsp_send_msg(adev, &request, NULL);
232 if (ret)
233 avs_ipc_err(adev, &request, "delete instance", ret);
234
235 return ret;
236}
237
238/*
239 * avs_ipc_bind - Bind two module instances
240 *
241 * @adev: Driver context
242 * @module_id: Source module-type id
243 * @instance_id: Source module instance id
244 * @dst_module_id: Sink module-type id
245 * @dst_instance_id: Sink module instance id
246 * @dst_queue: Sink module pin to bind @src_queue with
247 * @src_queue: Source module pin to bind @dst_queue with
248 */
249int avs_ipc_bind(struct avs_dev *adev, u16 module_id, u8 instance_id,
250 u16 dst_module_id, u8 dst_instance_id,
251 u8 dst_queue, u8 src_queue)
252{
253 union avs_module_msg msg = AVS_MODULE_REQUEST(BIND);
254 struct avs_ipc_msg request = {{0}};
255 int ret;
256
257 msg.module_id = module_id;
258 msg.instance_id = instance_id;
259 msg.ext.bind_unbind.dst_module_id = dst_module_id;
260 msg.ext.bind_unbind.dst_instance_id = dst_instance_id;
261 msg.ext.bind_unbind.dst_queue = dst_queue;
262 msg.ext.bind_unbind.src_queue = src_queue;
263 request.header = msg.val;
264
265 ret = avs_dsp_send_msg(adev, &request, NULL);
266 if (ret)
267 avs_ipc_err(adev, &request, "bind modules", ret);
268
269 return ret;
270}
271
272/*
273 * avs_ipc_unbind - Unbind two module instances
274 *
275 * @adev: Driver context
276 * @module_id: Source module-type id
277 * @instance_id: Source module instance id
278 * @dst_module_id: Sink module-type id
279 * @dst_instance_id: Sink module instance id
280 * @dst_queue: Sink module pin to unbind @src_queue from
281 * @src_queue: Source module pin to unbind @dst_queue from
282 */
283int avs_ipc_unbind(struct avs_dev *adev, u16 module_id, u8 instance_id,
284 u16 dst_module_id, u8 dst_instance_id,
285 u8 dst_queue, u8 src_queue)
286{
287 union avs_module_msg msg = AVS_MODULE_REQUEST(UNBIND);
288 struct avs_ipc_msg request = {{0}};
289 int ret;
290
291 msg.module_id = module_id;
292 msg.instance_id = instance_id;
293 msg.ext.bind_unbind.dst_module_id = dst_module_id;
294 msg.ext.bind_unbind.dst_instance_id = dst_instance_id;
295 msg.ext.bind_unbind.dst_queue = dst_queue;
296 msg.ext.bind_unbind.src_queue = src_queue;
297 request.header = msg.val;
298
299 ret = avs_dsp_send_msg(adev, &request, NULL);
300 if (ret)
301 avs_ipc_err(adev, &request, "unbind modules", ret);
302
303 return ret;
304}
305
306static int __avs_ipc_set_large_config(struct avs_dev *adev, u16 module_id, u8 instance_id,
307 u8 param_id, bool init_block, bool final_block,
308 u8 *request_data, size_t request_size, size_t off_size)
309{
310 union avs_module_msg msg = AVS_MODULE_REQUEST(LARGE_CONFIG_SET);
311 struct avs_ipc_msg request;
312 int ret;
313
314 msg.module_id = module_id;
315 msg.instance_id = instance_id;
316 msg.ext.large_config.data_off_size = off_size;
317 msg.ext.large_config.large_param_id = param_id;
318 msg.ext.large_config.final_block = final_block;
319 msg.ext.large_config.init_block = init_block;
320
321 request.header = msg.val;
322 request.data = request_data;
323 request.size = request_size;
324
325 ret = avs_dsp_send_msg(adev, &request, NULL);
326 if (ret)
327 avs_ipc_err(adev, &request, "large config set", ret);
328
329 return ret;
330}
331
332int avs_ipc_set_large_config(struct avs_dev *adev, u16 module_id,
333 u8 instance_id, u8 param_id,
334 u8 *request, size_t request_size)
335{
336 size_t remaining, tx_size;
337 bool final;
338 int ret;
339
340 remaining = request_size;
341 tx_size = min_t(size_t, AVS_MAILBOX_SIZE, remaining);
342 final = (tx_size == remaining);
343
344 /* Initial request states total payload size. */
345 ret = __avs_ipc_set_large_config(adev, module_id, instance_id,
346 param_id, 1, final, request, tx_size,
347 request_size);
348 if (ret)
349 return ret;
350
351 remaining -= tx_size;
352
353 /* Loop the rest only when payload exceeds mailbox's size. */
354 while (remaining) {
355 size_t offset;
356
357 offset = request_size - remaining;
358 tx_size = min_t(size_t, AVS_MAILBOX_SIZE, remaining);
359 final = (tx_size == remaining);
360
361 ret = __avs_ipc_set_large_config(adev, module_id, instance_id,
362 param_id, 0, final,
363 request + offset, tx_size,
364 offset);
365 if (ret)
366 return ret;
367
368 remaining -= tx_size;
369 }
370
371 return 0;
372}
373
374int avs_ipc_get_large_config(struct avs_dev *adev, u16 module_id, u8 instance_id,
375 u8 param_id, u8 *request_data, size_t request_size,
376 u8 **reply_data, size_t *reply_size)
377{
378 union avs_module_msg msg = AVS_MODULE_REQUEST(LARGE_CONFIG_GET);
379 struct avs_ipc_msg request;
380 struct avs_ipc_msg reply = {{0}};
381 void *buf;
382 int ret;
383
384 reply.data = kzalloc(AVS_MAILBOX_SIZE, GFP_KERNEL);
385 if (!reply.data)
386 return -ENOMEM;
387
388 msg.module_id = module_id;
389 msg.instance_id = instance_id;
390 msg.ext.large_config.data_off_size = request_size;
391 msg.ext.large_config.large_param_id = param_id;
392 /* final_block is always 0 on request. Updated by fw on reply. */
393 msg.ext.large_config.final_block = 0;
394 msg.ext.large_config.init_block = 1;
395
396 request.header = msg.val;
397 request.data = request_data;
398 request.size = request_size;
399 reply.size = AVS_MAILBOX_SIZE;
400
401 ret = avs_dsp_send_msg(adev, &request, &reply);
402 if (ret) {
403 avs_ipc_err(adev, &request, "large config get", ret);
404 kfree(reply.data);
405 return ret;
406 }
407
408 buf = krealloc(reply.data, reply.size, GFP_KERNEL);
409 if (!buf) {
410 kfree(reply.data);
411 return -ENOMEM;
412 }
413
414 *reply_data = buf;
415 *reply_size = reply.size;
416
417 return 0;
418}
419
420int avs_ipc_set_dx(struct avs_dev *adev, u32 core_mask, bool powerup)
421{
422 union avs_module_msg msg = AVS_MODULE_REQUEST(SET_DX);
423 struct avs_ipc_msg request;
424 struct avs_dxstate_info dx;
425 int ret;
426
427 dx.core_mask = core_mask;
428 dx.dx_mask = powerup ? core_mask : 0;
429 request.header = msg.val;
430 request.data = &dx;
431 request.size = sizeof(dx);
432
433 ret = avs_dsp_send_pm_msg(adev, &request, NULL, true);
434 if (ret)
435 avs_ipc_err(adev, &request, "set dx", ret);
436
437 return ret;
438}
439
440/*
441 * avs_ipc_set_d0ix - Set power gating policy (entering D0IX substates)
442 *
443 * @enable_pg: Whether to enable or disable power gating
444 * @streaming: Whether a stream is running when transitioning
445 */
446int avs_ipc_set_d0ix(struct avs_dev *adev, bool enable_pg, bool streaming)
447{
448 union avs_module_msg msg = AVS_MODULE_REQUEST(SET_D0IX);
449 struct avs_ipc_msg request = {{0}};
450 int ret;
451
452 msg.ext.set_d0ix.wake = enable_pg;
453 msg.ext.set_d0ix.streaming = streaming;
454
455 request.header = msg.val;
456
457 ret = avs_dsp_send_pm_msg(adev, &request, NULL, false);
458 if (ret)
459 avs_ipc_err(adev, &request, "set d0ix", ret);
460
461 return ret;
462}
463
464int avs_ipc_get_fw_config(struct avs_dev *adev, struct avs_fw_cfg *cfg)
465{
466 struct avs_tlv *tlv;
467 size_t payload_size;
468 size_t offset = 0;
469 u8 *payload;
470 int ret;
471
472 ret = avs_ipc_get_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
473 AVS_BASEFW_FIRMWARE_CONFIG, NULL, 0,
474 &payload, &payload_size);
475 if (ret)
476 return ret;
477 /* Non-zero payload expected for FIRMWARE_CONFIG. */
478 if (!payload_size)
479 return -EREMOTEIO;
480
481 while (offset < payload_size) {
482 tlv = (struct avs_tlv *)(payload + offset);
483
484 switch (tlv->type) {
485 case AVS_FW_CFG_FW_VERSION:
486 memcpy(&cfg->fw_version, tlv->value, sizeof(cfg->fw_version));
487 break;
488
489 case AVS_FW_CFG_MEMORY_RECLAIMED:
490 cfg->memory_reclaimed = *tlv->value;
491 break;
492
493 case AVS_FW_CFG_SLOW_CLOCK_FREQ_HZ:
494 cfg->slow_clock_freq_hz = *tlv->value;
495 break;
496
497 case AVS_FW_CFG_FAST_CLOCK_FREQ_HZ:
498 cfg->fast_clock_freq_hz = *tlv->value;
499 break;
500
501 case AVS_FW_CFG_ALH_SUPPORT_LEVEL:
502 cfg->alh_support = *tlv->value;
503 break;
504
505 case AVS_FW_CFG_IPC_DL_MAILBOX_BYTES:
506 cfg->ipc_dl_mailbox_bytes = *tlv->value;
507 break;
508
509 case AVS_FW_CFG_IPC_UL_MAILBOX_BYTES:
510 cfg->ipc_ul_mailbox_bytes = *tlv->value;
511 break;
512
513 case AVS_FW_CFG_TRACE_LOG_BYTES:
514 cfg->trace_log_bytes = *tlv->value;
515 break;
516
517 case AVS_FW_CFG_MAX_PPL_COUNT:
518 cfg->max_ppl_count = *tlv->value;
519 break;
520
521 case AVS_FW_CFG_MAX_ASTATE_COUNT:
522 cfg->max_astate_count = *tlv->value;
523 break;
524
525 case AVS_FW_CFG_MAX_MODULE_PIN_COUNT:
526 cfg->max_module_pin_count = *tlv->value;
527 break;
528
529 case AVS_FW_CFG_MODULES_COUNT:
530 cfg->modules_count = *tlv->value;
531 break;
532
533 case AVS_FW_CFG_MAX_MOD_INST_COUNT:
534 cfg->max_mod_inst_count = *tlv->value;
535 break;
536
537 case AVS_FW_CFG_MAX_LL_TASKS_PER_PRI_COUNT:
538 cfg->max_ll_tasks_per_pri_count = *tlv->value;
539 break;
540
541 case AVS_FW_CFG_LL_PRI_COUNT:
542 cfg->ll_pri_count = *tlv->value;
543 break;
544
545 case AVS_FW_CFG_MAX_DP_TASKS_COUNT:
546 cfg->max_dp_tasks_count = *tlv->value;
547 break;
548
549 case AVS_FW_CFG_MAX_LIBS_COUNT:
550 cfg->max_libs_count = *tlv->value;
551 break;
552
553 case AVS_FW_CFG_XTAL_FREQ_HZ:
554 cfg->xtal_freq_hz = *tlv->value;
555 break;
556
557 case AVS_FW_CFG_POWER_GATING_POLICY:
558 cfg->power_gating_policy = *tlv->value;
559 break;
560
561 /* Known but not useful to us. */
562 case AVS_FW_CFG_DMA_BUFFER_CONFIG:
563 case AVS_FW_CFG_SCHEDULER_CONFIG:
564 case AVS_FW_CFG_CLOCKS_CONFIG:
565 case AVS_FW_CFG_RESERVED:
566 break;
567
568 default:
569 dev_info(adev->dev, "Unrecognized fw param: %d\n", tlv->type);
570 break;
571 }
572
573 offset += sizeof(*tlv) + tlv->length;
574 }
575
576 /* No longer needed, free it as it's owned by the get_large_config() caller. */
577 kfree(payload);
578 return ret;
579}
580
581int avs_ipc_get_hw_config(struct avs_dev *adev, struct avs_hw_cfg *cfg)
582{
583 struct avs_tlv *tlv;
584 size_t payload_size;
585 size_t size, offset = 0;
586 u8 *payload;
587 int ret;
588
589 ret = avs_ipc_get_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
590 AVS_BASEFW_HARDWARE_CONFIG, NULL, 0,
591 &payload, &payload_size);
592 if (ret)
593 return ret;
594 /* Non-zero payload expected for HARDWARE_CONFIG. */
595 if (!payload_size)
596 return -EREMOTEIO;
597
598 while (offset < payload_size) {
599 tlv = (struct avs_tlv *)(payload + offset);
600
601 switch (tlv->type) {
602 case AVS_HW_CFG_AVS_VER:
603 cfg->avs_version = *tlv->value;
604 break;
605
606 case AVS_HW_CFG_DSP_CORES:
607 cfg->dsp_cores = *tlv->value;
608 break;
609
610 case AVS_HW_CFG_MEM_PAGE_BYTES:
611 cfg->mem_page_bytes = *tlv->value;
612 break;
613
614 case AVS_HW_CFG_TOTAL_PHYS_MEM_PAGES:
615 cfg->total_phys_mem_pages = *tlv->value;
616 break;
617
618 case AVS_HW_CFG_I2S_CAPS:
619 cfg->i2s_caps.i2s_version = tlv->value[0];
620 size = tlv->value[1];
621 cfg->i2s_caps.ctrl_count = size;
622 if (!size)
623 break;
624
625 /* Multiply to get entire array size. */
626 size *= sizeof(*cfg->i2s_caps.ctrl_base_addr);
627 cfg->i2s_caps.ctrl_base_addr = devm_kmemdup(adev->dev,
628 &tlv->value[2],
629 size, GFP_KERNEL);
630 if (!cfg->i2s_caps.ctrl_base_addr) {
631 ret = -ENOMEM;
632 goto exit;
633 }
634 break;
635
636 case AVS_HW_CFG_GATEWAY_COUNT:
637 cfg->gateway_count = *tlv->value;
638 break;
639
640 case AVS_HW_CFG_HP_EBB_COUNT:
641 cfg->hp_ebb_count = *tlv->value;
642 break;
643
644 case AVS_HW_CFG_LP_EBB_COUNT:
645 cfg->lp_ebb_count = *tlv->value;
646 break;
647
648 case AVS_HW_CFG_EBB_SIZE_BYTES:
649 cfg->ebb_size_bytes = *tlv->value;
650 break;
651
652 case AVS_HW_CFG_GPDMA_CAPS:
653 break;
654
655 default:
656 dev_info(adev->dev, "Unrecognized hw config: %d\n", tlv->type);
657 break;
658 }
659
660 offset += sizeof(*tlv) + tlv->length;
661 }
662
663exit:
664 /* No longer needed, free it as it's owned by the get_large_config() caller. */
665 kfree(payload);
666 return ret;
667}
668
669int avs_ipc_get_modules_info(struct avs_dev *adev, struct avs_mods_info **info)
670{
671 size_t payload_size;
672 u8 *payload;
673 int ret;
674
675 ret = avs_ipc_get_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
676 AVS_BASEFW_MODULES_INFO, NULL, 0,
677 &payload, &payload_size);
678 if (ret)
679 return ret;
680 /* Non-zero payload expected for MODULES_INFO. */
681 if (!payload_size)
682 return -EREMOTEIO;
683
684 *info = (struct avs_mods_info *)payload;
685 return 0;
686}
687
688int avs_ipc_copier_set_sink_format(struct avs_dev *adev, u16 module_id,
689 u8 instance_id, u32 sink_id,
690 const struct avs_audio_format *src_fmt,
691 const struct avs_audio_format *sink_fmt)
692{
693 struct avs_copier_sink_format cpr_fmt;
694
695 cpr_fmt.sink_id = sink_id;
696 /* Firmware expects driver to resend copier's input format. */
697 cpr_fmt.src_fmt = *src_fmt;
698 cpr_fmt.sink_fmt = *sink_fmt;
699
700 return avs_ipc_set_large_config(adev, module_id, instance_id,
701 AVS_COPIER_SET_SINK_FORMAT,
702 (u8 *)&cpr_fmt, sizeof(cpr_fmt));
703}
704
705#ifdef CONFIG_DEBUG_FS
706int avs_ipc_set_enable_logs(struct avs_dev *adev, u8 *log_info, size_t size)
707{
708 return avs_ipc_set_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
709 AVS_BASEFW_ENABLE_LOGS, log_info, size);
710}
711
712int avs_ipc_set_system_time(struct avs_dev *adev)
713{
714 struct avs_sys_time sys_time;
715 u64 us;
716
717 /* firmware expects UTC time in micro seconds */
718 us = ktime_to_us(ktime_get());
719 sys_time.val_l = us & UINT_MAX;
720 sys_time.val_u = us >> 32;
721
722 return avs_ipc_set_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
723 AVS_BASEFW_SYSTEM_TIME, (u8 *)&sys_time, sizeof(sys_time));
724}
725
726int avs_ipc_probe_get_dma(struct avs_dev *adev, struct avs_probe_dma **dmas, size_t *num_dmas)
727{
728 size_t payload_size;
729 u32 module_id;
730 u8 *payload;
731 int ret;
732
733 module_id = avs_get_module_id(adev, &AVS_PROBE_MOD_UUID);
734
735 ret = avs_ipc_get_large_config(adev, module_id, AVS_PROBE_INST_ID, AVS_PROBE_INJECTION_DMA,
736 NULL, 0, &payload, &payload_size);
737 if (ret)
738 return ret;
739
740 *dmas = (struct avs_probe_dma *)payload;
741 *num_dmas = payload_size / sizeof(**dmas);
742
743 return 0;
744}
745
746int avs_ipc_probe_attach_dma(struct avs_dev *adev, struct avs_probe_dma *dmas, size_t num_dmas)
747{
748 u32 module_id = avs_get_module_id(adev, &AVS_PROBE_MOD_UUID);
749
750 return avs_ipc_set_large_config(adev, module_id, AVS_PROBE_INST_ID, AVS_PROBE_INJECTION_DMA,
751 (u8 *)dmas, array_size(sizeof(*dmas), num_dmas));
752}
753
754int avs_ipc_probe_detach_dma(struct avs_dev *adev, union avs_connector_node_id *node_ids,
755 size_t num_node_ids)
756{
757 u32 module_id = avs_get_module_id(adev, &AVS_PROBE_MOD_UUID);
758
759 return avs_ipc_set_large_config(adev, module_id, AVS_PROBE_INST_ID,
760 AVS_PROBE_INJECTION_DMA_DETACH, (u8 *)node_ids,
761 array_size(sizeof(*node_ids), num_node_ids));
762}
763
764int avs_ipc_probe_get_points(struct avs_dev *adev, struct avs_probe_point_desc **descs,
765 size_t *num_descs)
766{
767 size_t payload_size;
768 u32 module_id;
769 u8 *payload;
770 int ret;
771
772 module_id = avs_get_module_id(adev, &AVS_PROBE_MOD_UUID);
773
774 ret = avs_ipc_get_large_config(adev, module_id, AVS_PROBE_INST_ID, AVS_PROBE_POINTS, NULL,
775 0, &payload, &payload_size);
776 if (ret)
777 return ret;
778
779 *descs = (struct avs_probe_point_desc *)payload;
780 *num_descs = payload_size / sizeof(**descs);
781
782 return 0;
783}
784
785int avs_ipc_probe_connect_points(struct avs_dev *adev, struct avs_probe_point_desc *descs,
786 size_t num_descs)
787{
788 u32 module_id = avs_get_module_id(adev, &AVS_PROBE_MOD_UUID);
789
790 return avs_ipc_set_large_config(adev, module_id, AVS_PROBE_INST_ID, AVS_PROBE_POINTS,
791 (u8 *)descs, array_size(sizeof(*descs), num_descs));
792}
793
794int avs_ipc_probe_disconnect_points(struct avs_dev *adev, union avs_probe_point_id *ids,
795 size_t num_ids)
796{
797 u32 module_id = avs_get_module_id(adev, &AVS_PROBE_MOD_UUID);
798
799 return avs_ipc_set_large_config(adev, module_id, AVS_PROBE_INST_ID,
800 AVS_PROBE_POINTS_DISCONNECT, (u8 *)ids,
801 array_size(sizeof(*ids), num_ids));
802}
803#endif