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: &request, name: "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: &request, NULL, AVS_CL_TIMEOUT_MS,
39 name: "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: &request, NULL, name: "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: &request, NULL, AVS_CL_TIMEOUT_MS, name: "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: &request, NULL, name: "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: &request, NULL, name: "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: &request, NULL, name: "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: &request, reply: &reply, name: "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: &request, NULL, name: "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: &request, NULL, name: "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: &request, NULL, name: "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: &request, NULL, name: "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: &request, NULL, name: "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, init_block: 1, final_block: final, request_data: request, request_size: tx_size,
284 off_size: 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, init_block: 0, final_block: final,
300 request_data: request + offset, request_size: tx_size,
301 off_size: 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: &request, reply: &reply, name: "large config get");
339 if (ret) {
340 kfree(objp: reply.data);
341 return ret;
342 }
343
344 buf = krealloc(reply.data, reply.size, GFP_KERNEL);
345 if (!buf) {
346 kfree(objp: 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: &request, NULL, wake_d0i0: true, name: "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: &request, NULL, wake_d0i0: false, name: "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 param_id: AVS_BASEFW_FIRMWARE_CONFIG, NULL, request_size: 0,
401 reply_data: &payload, reply_size: &payload_size);
402 if (ret)
403 goto err;
404 /* Non-zero payload expected for FIRMWARE_CONFIG. */
405 if (!payload_size) {
406 ret = -EREMOTEIO;
407 goto err;
408 }
409
410 while (offset < payload_size) {
411 tlv = (struct avs_tlv *)(payload + offset);
412
413 switch (tlv->type) {
414 case AVS_FW_CFG_FW_VERSION:
415 memcpy(&cfg->fw_version, tlv->value, sizeof(cfg->fw_version));
416 break;
417
418 case AVS_FW_CFG_MEMORY_RECLAIMED:
419 cfg->memory_reclaimed = *tlv->value;
420 break;
421
422 case AVS_FW_CFG_SLOW_CLOCK_FREQ_HZ:
423 cfg->slow_clock_freq_hz = *tlv->value;
424 break;
425
426 case AVS_FW_CFG_FAST_CLOCK_FREQ_HZ:
427 cfg->fast_clock_freq_hz = *tlv->value;
428 break;
429
430 case AVS_FW_CFG_ALH_SUPPORT_LEVEL:
431 cfg->alh_support = *tlv->value;
432 break;
433
434 case AVS_FW_CFG_IPC_DL_MAILBOX_BYTES:
435 cfg->ipc_dl_mailbox_bytes = *tlv->value;
436 break;
437
438 case AVS_FW_CFG_IPC_UL_MAILBOX_BYTES:
439 cfg->ipc_ul_mailbox_bytes = *tlv->value;
440 break;
441
442 case AVS_FW_CFG_TRACE_LOG_BYTES:
443 cfg->trace_log_bytes = *tlv->value;
444 break;
445
446 case AVS_FW_CFG_MAX_PPL_COUNT:
447 cfg->max_ppl_count = *tlv->value;
448 break;
449
450 case AVS_FW_CFG_MAX_ASTATE_COUNT:
451 cfg->max_astate_count = *tlv->value;
452 break;
453
454 case AVS_FW_CFG_MAX_MODULE_PIN_COUNT:
455 cfg->max_module_pin_count = *tlv->value;
456 break;
457
458 case AVS_FW_CFG_MODULES_COUNT:
459 cfg->modules_count = *tlv->value;
460 break;
461
462 case AVS_FW_CFG_MAX_MOD_INST_COUNT:
463 cfg->max_mod_inst_count = *tlv->value;
464 break;
465
466 case AVS_FW_CFG_MAX_LL_TASKS_PER_PRI_COUNT:
467 cfg->max_ll_tasks_per_pri_count = *tlv->value;
468 break;
469
470 case AVS_FW_CFG_LL_PRI_COUNT:
471 cfg->ll_pri_count = *tlv->value;
472 break;
473
474 case AVS_FW_CFG_MAX_DP_TASKS_COUNT:
475 cfg->max_dp_tasks_count = *tlv->value;
476 break;
477
478 case AVS_FW_CFG_MAX_LIBS_COUNT:
479 cfg->max_libs_count = *tlv->value;
480 break;
481
482 case AVS_FW_CFG_XTAL_FREQ_HZ:
483 cfg->xtal_freq_hz = *tlv->value;
484 break;
485
486 case AVS_FW_CFG_POWER_GATING_POLICY:
487 cfg->power_gating_policy = *tlv->value;
488 break;
489
490 /* Known but not useful to us. */
491 case AVS_FW_CFG_DMA_BUFFER_CONFIG:
492 case AVS_FW_CFG_SCHEDULER_CONFIG:
493 case AVS_FW_CFG_CLOCKS_CONFIG:
494 case AVS_FW_CFG_RESERVED:
495 break;
496
497 default:
498 dev_info(adev->dev, "Unrecognized fw param: %d\n", tlv->type);
499 break;
500 }
501
502 offset += sizeof(*tlv) + tlv->length;
503 }
504
505 /* No longer needed, free it as it's owned by the get_large_config() caller. */
506 kfree(objp: payload);
507err:
508 if (ret)
509 dev_err(adev->dev, "get fw cfg failed: %d\n", ret);
510 return ret;
511}
512
513int avs_ipc_set_fw_config(struct avs_dev *adev, size_t num_tlvs, ...)
514{
515 struct avs_tlv *tlv;
516 void *payload;
517 size_t offset;
518 va_list args;
519 int ret, i;
520
521 payload = kzalloc(AVS_MAILBOX_SIZE, GFP_KERNEL);
522 if (!payload)
523 return -ENOMEM;
524
525 va_start(args, num_tlvs);
526 for (offset = i = 0; i < num_tlvs && offset < AVS_MAILBOX_SIZE - sizeof(*tlv); i++) {
527 tlv = (struct avs_tlv *)(payload + offset);
528 tlv->type = va_arg(args, u32);
529 tlv->length = va_arg(args, u32);
530
531 offset += sizeof(*tlv) + tlv->length;
532 if (offset > AVS_MAILBOX_SIZE)
533 break;
534
535 memcpy(tlv->value, va_arg(args, u8*), tlv->length);
536 }
537
538 if (i == num_tlvs)
539 ret = avs_ipc_set_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
540 param_id: AVS_BASEFW_FIRMWARE_CONFIG, request: payload, request_size: offset);
541 else
542 ret = -ERANGE;
543
544 va_end(args);
545 kfree(objp: payload);
546 if (ret)
547 dev_err(adev->dev, "set fw cfg failed: %d\n", ret);
548 return ret;
549}
550
551int avs_ipc_get_hw_config(struct avs_dev *adev, struct avs_hw_cfg *cfg)
552{
553 struct avs_tlv *tlv;
554 size_t payload_size;
555 size_t size, offset = 0;
556 u8 *payload;
557 int ret;
558
559 ret = avs_ipc_get_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
560 param_id: AVS_BASEFW_HARDWARE_CONFIG, NULL, request_size: 0,
561 reply_data: &payload, reply_size: &payload_size);
562 if (ret)
563 goto err;
564 /* Non-zero payload expected for HARDWARE_CONFIG. */
565 if (!payload_size) {
566 ret = -EREMOTEIO;
567 goto err;
568 }
569
570 while (offset < payload_size) {
571 tlv = (struct avs_tlv *)(payload + offset);
572
573 switch (tlv->type) {
574 case AVS_HW_CFG_AVS_VER:
575 cfg->avs_version = *tlv->value;
576 break;
577
578 case AVS_HW_CFG_DSP_CORES:
579 cfg->dsp_cores = *tlv->value;
580 break;
581
582 case AVS_HW_CFG_MEM_PAGE_BYTES:
583 cfg->mem_page_bytes = *tlv->value;
584 break;
585
586 case AVS_HW_CFG_TOTAL_PHYS_MEM_PAGES:
587 cfg->total_phys_mem_pages = *tlv->value;
588 break;
589
590 case AVS_HW_CFG_I2S_CAPS:
591 cfg->i2s_caps.i2s_version = tlv->value[0];
592 size = tlv->value[1];
593 cfg->i2s_caps.ctrl_count = size;
594 if (!size)
595 break;
596
597 /* Multiply to get entire array size. */
598 size *= sizeof(*cfg->i2s_caps.ctrl_base_addr);
599 cfg->i2s_caps.ctrl_base_addr = devm_kmemdup(dev: adev->dev,
600 src: &tlv->value[2],
601 len: size, GFP_KERNEL);
602 if (!cfg->i2s_caps.ctrl_base_addr) {
603 ret = -ENOMEM;
604 goto exit;
605 }
606 break;
607
608 case AVS_HW_CFG_GATEWAY_COUNT:
609 cfg->gateway_count = *tlv->value;
610 break;
611
612 case AVS_HW_CFG_HP_EBB_COUNT:
613 cfg->hp_ebb_count = *tlv->value;
614 break;
615
616 case AVS_HW_CFG_LP_EBB_COUNT:
617 cfg->lp_ebb_count = *tlv->value;
618 break;
619
620 case AVS_HW_CFG_EBB_SIZE_BYTES:
621 cfg->ebb_size_bytes = *tlv->value;
622 break;
623
624 case AVS_HW_CFG_GPDMA_CAPS:
625 break;
626
627 default:
628 dev_info(adev->dev, "Unrecognized hw config: %d\n", tlv->type);
629 break;
630 }
631
632 offset += sizeof(*tlv) + tlv->length;
633 }
634
635exit:
636 /* No longer needed, free it as it's owned by the get_large_config() caller. */
637 kfree(objp: payload);
638err:
639 if (ret)
640 dev_err(adev->dev, "get hw cfg failed: %d\n", ret);
641 return ret;
642}
643
644int avs_ipc_get_modules_info(struct avs_dev *adev, struct avs_mods_info **info)
645{
646 size_t payload_size;
647 u8 *payload;
648 int ret;
649
650 ret = avs_ipc_get_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
651 param_id: AVS_BASEFW_MODULES_INFO, NULL, request_size: 0,
652 reply_data: &payload, reply_size: &payload_size);
653 if (ret)
654 return ret;
655 /* Non-zero payload expected for MODULES_INFO. */
656 if (!payload_size)
657 return -EREMOTEIO;
658
659 *info = (struct avs_mods_info *)payload;
660 return 0;
661}
662
663int avs_ipc_copier_set_sink_format(struct avs_dev *adev, u16 module_id,
664 u8 instance_id, u32 sink_id,
665 const struct avs_audio_format *src_fmt,
666 const struct avs_audio_format *sink_fmt)
667{
668 struct avs_copier_sink_format cpr_fmt;
669
670 cpr_fmt.sink_id = sink_id;
671 /* Firmware expects driver to resend copier's input format. */
672 cpr_fmt.src_fmt = *src_fmt;
673 cpr_fmt.sink_fmt = *sink_fmt;
674
675 return avs_ipc_set_large_config(adev, module_id, instance_id,
676 param_id: AVS_COPIER_SET_SINK_FORMAT,
677 request: (u8 *)&cpr_fmt, request_size: sizeof(cpr_fmt));
678}
679
680int avs_ipc_peakvol_get_volume(struct avs_dev *adev, u16 module_id, u8 instance_id,
681 struct avs_volume_cfg **vols, size_t *num_vols)
682{
683 size_t payload_size;
684 u8 *payload;
685 int ret;
686
687 ret = avs_ipc_get_large_config(adev, module_id, instance_id, param_id: AVS_PEAKVOL_VOLUME, NULL, request_size: 0,
688 reply_data: &payload, reply_size: &payload_size);
689 if (ret)
690 return ret;
691
692 /* Non-zero payload expected for PEAKVOL_VOLUME. */
693 if (!payload_size)
694 return -EREMOTEIO;
695
696 *vols = (struct avs_volume_cfg *)payload;
697 *num_vols = payload_size / sizeof(**vols);
698
699 return 0;
700}
701
702int avs_ipc_peakvol_set_volume(struct avs_dev *adev, u16 module_id, u8 instance_id,
703 struct avs_volume_cfg *vol)
704{
705 return avs_ipc_set_large_config(adev, module_id, instance_id, param_id: AVS_PEAKVOL_VOLUME,
706 request: (u8 *)vol, request_size: sizeof(*vol));
707}
708
709int avs_ipc_peakvol_set_volumes(struct avs_dev *adev, u16 module_id, u8 instance_id,
710 struct avs_volume_cfg *vols, size_t num_vols)
711{
712 struct avs_tlv *tlv;
713 size_t offset;
714 size_t size;
715 u8 *payload;
716 int ret, i;
717
718 size = num_vols * sizeof(*vols);
719 size += num_vols * sizeof(*tlv);
720 if (size > AVS_MAILBOX_SIZE)
721 return -EINVAL;
722
723 payload = kzalloc(AVS_MAILBOX_SIZE, GFP_KERNEL);
724 if (!payload)
725 return -ENOMEM;
726
727 for (offset = i = 0; i < num_vols; i++) {
728 tlv = (struct avs_tlv *)(payload + offset);
729
730 tlv->type = AVS_PEAKVOL_VOLUME;
731 tlv->length = sizeof(*vols);
732 memcpy(tlv->value, &vols[i], tlv->length);
733
734 offset += sizeof(*tlv) + tlv->length;
735 }
736
737 ret = avs_ipc_set_large_config(adev, module_id, instance_id, AVS_VENDOR_CONFIG, request: payload,
738 request_size: size);
739 kfree(objp: payload);
740 return ret;
741}
742
743int avs_ipc_peakvol_get_mute(struct avs_dev *adev, u16 module_id, u8 instance_id,
744 struct avs_mute_cfg **mutes, size_t *num_mutes)
745{
746 size_t payload_size;
747 u8 *payload;
748 int ret;
749
750 ret = avs_ipc_get_large_config(adev, module_id, instance_id, param_id: AVS_PEAKVOL_MUTE, NULL, request_size: 0,
751 reply_data: &payload, reply_size: &payload_size);
752 if (ret)
753 return ret;
754
755 /* Non-zero payload expected for PEAKVOL_MUTE. */
756 if (!payload_size)
757 return -EREMOTEIO;
758
759 *mutes = (struct avs_mute_cfg *)payload;
760 *num_mutes = payload_size / sizeof(**mutes);
761
762 return 0;
763}
764
765int avs_ipc_peakvol_set_mute(struct avs_dev *adev, u16 module_id, u8 instance_id,
766 struct avs_mute_cfg *mute)
767{
768 return avs_ipc_set_large_config(adev, module_id, instance_id, param_id: AVS_PEAKVOL_MUTE,
769 request: (u8 *)mute, request_size: sizeof(*mute));
770}
771
772int avs_ipc_peakvol_set_mutes(struct avs_dev *adev, u16 module_id, u8 instance_id,
773 struct avs_mute_cfg *mutes, size_t num_mutes)
774{
775 struct avs_tlv *tlv;
776 size_t offset;
777 size_t size;
778 u8 *payload;
779 int ret, i;
780
781 size = num_mutes * sizeof(*mutes);
782 size += num_mutes * sizeof(*tlv);
783 if (size > AVS_MAILBOX_SIZE)
784 return -EINVAL;
785
786 payload = kzalloc(AVS_MAILBOX_SIZE, GFP_KERNEL);
787 if (!payload)
788 return -ENOMEM;
789
790 for (offset = i = 0; i < num_mutes; i++) {
791 tlv = (struct avs_tlv *)(payload + offset);
792
793 tlv->type = AVS_PEAKVOL_MUTE;
794 tlv->length = sizeof(*mutes);
795 memcpy(tlv->value, &mutes[i], tlv->length);
796
797 offset += sizeof(*tlv) + tlv->length;
798 }
799
800 ret = avs_ipc_set_large_config(adev, module_id, instance_id, AVS_VENDOR_CONFIG, request: payload,
801 request_size: size);
802 kfree(objp: payload);
803 return ret;
804}
805
806#ifdef CONFIG_DEBUG_FS
807int avs_ipc_set_enable_logs(struct avs_dev *adev, u8 *log_info, size_t size)
808{
809 return avs_ipc_set_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
810 param_id: AVS_BASEFW_ENABLE_LOGS, request: log_info, request_size: size);
811}
812
813int avs_ipc_set_system_time(struct avs_dev *adev)
814{
815 struct avs_sys_time sys_time;
816 u64 us;
817
818 /* firmware expects UTC time in micro seconds */
819 us = ktime_to_us(kt: ktime_get());
820 sys_time.val_l = us & UINT_MAX;
821 sys_time.val_u = us >> 32;
822
823 return avs_ipc_set_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
824 param_id: AVS_BASEFW_SYSTEM_TIME, request: (u8 *)&sys_time, request_size: sizeof(sys_time));
825}
826
827int avs_ipc_probe_get_dma(struct avs_dev *adev, struct avs_probe_dma **dmas, size_t *num_dmas)
828{
829 size_t payload_size;
830 u32 module_id;
831 u8 *payload;
832 int ret;
833
834 module_id = avs_get_module_id(adev, uuid: &AVS_PROBE_MOD_UUID);
835
836 ret = avs_ipc_get_large_config(adev, module_id, AVS_PROBE_INST_ID, param_id: AVS_PROBE_INJECTION_DMA,
837 NULL, request_size: 0, reply_data: &payload, reply_size: &payload_size);
838 if (ret)
839 return ret;
840
841 *dmas = (struct avs_probe_dma *)payload;
842 *num_dmas = payload_size / sizeof(**dmas);
843
844 return 0;
845}
846
847int avs_ipc_probe_attach_dma(struct avs_dev *adev, struct avs_probe_dma *dmas, size_t num_dmas)
848{
849 u32 module_id = avs_get_module_id(adev, uuid: &AVS_PROBE_MOD_UUID);
850
851 return avs_ipc_set_large_config(adev, module_id, AVS_PROBE_INST_ID, param_id: AVS_PROBE_INJECTION_DMA,
852 request: (u8 *)dmas, array_size(sizeof(*dmas), num_dmas));
853}
854
855int avs_ipc_probe_detach_dma(struct avs_dev *adev, union avs_connector_node_id *node_ids,
856 size_t num_node_ids)
857{
858 u32 module_id = avs_get_module_id(adev, uuid: &AVS_PROBE_MOD_UUID);
859
860 return avs_ipc_set_large_config(adev, module_id, AVS_PROBE_INST_ID,
861 param_id: AVS_PROBE_INJECTION_DMA_DETACH, request: (u8 *)node_ids,
862 array_size(sizeof(*node_ids), num_node_ids));
863}
864
865int avs_ipc_probe_get_points(struct avs_dev *adev, struct avs_probe_point_desc **descs,
866 size_t *num_descs)
867{
868 size_t payload_size;
869 u32 module_id;
870 u8 *payload;
871 int ret;
872
873 module_id = avs_get_module_id(adev, uuid: &AVS_PROBE_MOD_UUID);
874
875 ret = avs_ipc_get_large_config(adev, module_id, AVS_PROBE_INST_ID, param_id: AVS_PROBE_POINTS, NULL,
876 request_size: 0, reply_data: &payload, reply_size: &payload_size);
877 if (ret)
878 return ret;
879
880 *descs = (struct avs_probe_point_desc *)payload;
881 *num_descs = payload_size / sizeof(**descs);
882
883 return 0;
884}
885
886int avs_ipc_probe_connect_points(struct avs_dev *adev, struct avs_probe_point_desc *descs,
887 size_t num_descs)
888{
889 u32 module_id = avs_get_module_id(adev, uuid: &AVS_PROBE_MOD_UUID);
890
891 return avs_ipc_set_large_config(adev, module_id, AVS_PROBE_INST_ID, param_id: AVS_PROBE_POINTS,
892 request: (u8 *)descs, array_size(sizeof(*descs), num_descs));
893}
894
895int avs_ipc_probe_disconnect_points(struct avs_dev *adev, union avs_probe_point_id *ids,
896 size_t num_ids)
897{
898 u32 module_id = avs_get_module_id(adev, uuid: &AVS_PROBE_MOD_UUID);
899
900 return avs_ipc_set_large_config(adev, module_id, AVS_PROBE_INST_ID,
901 param_id: AVS_PROBE_POINTS_DISCONNECT, request: (u8 *)ids,
902 array_size(sizeof(*ids), num_ids));
903}
904#endif
905

source code of linux/sound/soc/intel/avs/messages.c