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 15 int 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 33 int 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 51 int 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_timeout(adev, &request, NULL, AVS_CL_TIMEOUT_MS); 63 if (ret) 64 avs_ipc_err(adev, &request, "unload multiple modules", ret); 65 66 return ret; 67 } 68 69 int 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 86 int 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 107 int 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 123 int 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 141 int 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 */ 180 int 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 */ 221 int 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 */ 249 int 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 */ 283 int 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 306 static 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 332 int 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 374 int 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 size_t size; 382 void *buf; 383 int ret; 384 385 reply.data = kzalloc(AVS_MAILBOX_SIZE, GFP_KERNEL); 386 if (!reply.data) 387 return -ENOMEM; 388 389 msg.module_id = module_id; 390 msg.instance_id = instance_id; 391 msg.ext.large_config.data_off_size = request_size; 392 msg.ext.large_config.large_param_id = param_id; 393 /* final_block is always 0 on request. Updated by fw on reply. */ 394 msg.ext.large_config.final_block = 0; 395 msg.ext.large_config.init_block = 1; 396 397 request.header = msg.val; 398 request.data = request_data; 399 request.size = request_size; 400 reply.size = AVS_MAILBOX_SIZE; 401 402 ret = avs_dsp_send_msg(adev, &request, &reply); 403 if (ret) { 404 avs_ipc_err(adev, &request, "large config get", ret); 405 kfree(reply.data); 406 return ret; 407 } 408 409 size = reply.rsp.ext.large_config.data_off_size; 410 buf = krealloc(reply.data, size, GFP_KERNEL); 411 if (!buf) { 412 kfree(reply.data); 413 return -ENOMEM; 414 } 415 416 *reply_data = buf; 417 *reply_size = size; 418 419 return 0; 420 } 421 422 int avs_ipc_set_dx(struct avs_dev *adev, u32 core_mask, bool powerup) 423 { 424 union avs_module_msg msg = AVS_MODULE_REQUEST(SET_DX); 425 struct avs_ipc_msg request; 426 struct avs_dxstate_info dx; 427 int ret; 428 429 dx.core_mask = core_mask; 430 dx.dx_mask = powerup ? core_mask : 0; 431 request.header = msg.val; 432 request.data = &dx; 433 request.size = sizeof(dx); 434 435 ret = avs_dsp_send_pm_msg(adev, &request, NULL, true); 436 if (ret) 437 avs_ipc_err(adev, &request, "set dx", ret); 438 439 return ret; 440 } 441 442 /* 443 * avs_ipc_set_d0ix - Set power gating policy (entering D0IX substates) 444 * 445 * @enable_pg: Whether to enable or disable power gating 446 * @streaming: Whether a stream is running when transitioning 447 */ 448 int avs_ipc_set_d0ix(struct avs_dev *adev, bool enable_pg, bool streaming) 449 { 450 union avs_module_msg msg = AVS_MODULE_REQUEST(SET_D0IX); 451 struct avs_ipc_msg request = {{0}}; 452 int ret; 453 454 msg.ext.set_d0ix.wake = enable_pg; 455 msg.ext.set_d0ix.streaming = streaming; 456 457 request.header = msg.val; 458 459 ret = avs_dsp_send_pm_msg(adev, &request, NULL, false); 460 if (ret) 461 avs_ipc_err(adev, &request, "set d0ix", ret); 462 463 return ret; 464 } 465 466 int avs_ipc_get_fw_config(struct avs_dev *adev, struct avs_fw_cfg *cfg) 467 { 468 struct avs_tlv *tlv; 469 size_t payload_size; 470 size_t offset = 0; 471 u8 *payload; 472 int ret; 473 474 ret = avs_ipc_get_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID, 475 AVS_BASEFW_FIRMWARE_CONFIG, NULL, 0, 476 &payload, &payload_size); 477 if (ret) 478 return ret; 479 480 while (offset < payload_size) { 481 tlv = (struct avs_tlv *)(payload + offset); 482 483 switch (tlv->type) { 484 case AVS_FW_CFG_FW_VERSION: 485 memcpy(&cfg->fw_version, tlv->value, sizeof(cfg->fw_version)); 486 break; 487 488 case AVS_FW_CFG_MEMORY_RECLAIMED: 489 cfg->memory_reclaimed = *tlv->value; 490 break; 491 492 case AVS_FW_CFG_SLOW_CLOCK_FREQ_HZ: 493 cfg->slow_clock_freq_hz = *tlv->value; 494 break; 495 496 case AVS_FW_CFG_FAST_CLOCK_FREQ_HZ: 497 cfg->fast_clock_freq_hz = *tlv->value; 498 break; 499 500 case AVS_FW_CFG_ALH_SUPPORT_LEVEL: 501 cfg->alh_support = *tlv->value; 502 break; 503 504 case AVS_FW_CFG_IPC_DL_MAILBOX_BYTES: 505 cfg->ipc_dl_mailbox_bytes = *tlv->value; 506 break; 507 508 case AVS_FW_CFG_IPC_UL_MAILBOX_BYTES: 509 cfg->ipc_ul_mailbox_bytes = *tlv->value; 510 break; 511 512 case AVS_FW_CFG_TRACE_LOG_BYTES: 513 cfg->trace_log_bytes = *tlv->value; 514 break; 515 516 case AVS_FW_CFG_MAX_PPL_COUNT: 517 cfg->max_ppl_count = *tlv->value; 518 break; 519 520 case AVS_FW_CFG_MAX_ASTATE_COUNT: 521 cfg->max_astate_count = *tlv->value; 522 break; 523 524 case AVS_FW_CFG_MAX_MODULE_PIN_COUNT: 525 cfg->max_module_pin_count = *tlv->value; 526 break; 527 528 case AVS_FW_CFG_MODULES_COUNT: 529 cfg->modules_count = *tlv->value; 530 break; 531 532 case AVS_FW_CFG_MAX_MOD_INST_COUNT: 533 cfg->max_mod_inst_count = *tlv->value; 534 break; 535 536 case AVS_FW_CFG_MAX_LL_TASKS_PER_PRI_COUNT: 537 cfg->max_ll_tasks_per_pri_count = *tlv->value; 538 break; 539 540 case AVS_FW_CFG_LL_PRI_COUNT: 541 cfg->ll_pri_count = *tlv->value; 542 break; 543 544 case AVS_FW_CFG_MAX_DP_TASKS_COUNT: 545 cfg->max_dp_tasks_count = *tlv->value; 546 break; 547 548 case AVS_FW_CFG_MAX_LIBS_COUNT: 549 cfg->max_libs_count = *tlv->value; 550 break; 551 552 case AVS_FW_CFG_XTAL_FREQ_HZ: 553 cfg->xtal_freq_hz = *tlv->value; 554 break; 555 556 case AVS_FW_CFG_POWER_GATING_POLICY: 557 cfg->power_gating_policy = *tlv->value; 558 break; 559 560 /* Known but not useful to us. */ 561 case AVS_FW_CFG_DMA_BUFFER_CONFIG: 562 case AVS_FW_CFG_SCHEDULER_CONFIG: 563 case AVS_FW_CFG_CLOCKS_CONFIG: 564 break; 565 566 default: 567 dev_info(adev->dev, "Unrecognized fw param: %d\n", tlv->type); 568 break; 569 } 570 571 offset += sizeof(*tlv) + tlv->length; 572 } 573 574 /* No longer needed, free it as it's owned by the get_large_config() caller. */ 575 kfree(payload); 576 return ret; 577 } 578 579 int avs_ipc_get_hw_config(struct avs_dev *adev, struct avs_hw_cfg *cfg) 580 { 581 struct avs_tlv *tlv; 582 size_t payload_size; 583 size_t size, offset = 0; 584 u8 *payload; 585 int ret; 586 587 ret = avs_ipc_get_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID, 588 AVS_BASEFW_HARDWARE_CONFIG, NULL, 0, 589 &payload, &payload_size); 590 if (ret) 591 return ret; 592 593 while (offset < payload_size) { 594 tlv = (struct avs_tlv *)(payload + offset); 595 596 switch (tlv->type) { 597 case AVS_HW_CFG_AVS_VER: 598 cfg->avs_version = *tlv->value; 599 break; 600 601 case AVS_HW_CFG_DSP_CORES: 602 cfg->dsp_cores = *tlv->value; 603 break; 604 605 case AVS_HW_CFG_MEM_PAGE_BYTES: 606 cfg->mem_page_bytes = *tlv->value; 607 break; 608 609 case AVS_HW_CFG_TOTAL_PHYS_MEM_PAGES: 610 cfg->total_phys_mem_pages = *tlv->value; 611 break; 612 613 case AVS_HW_CFG_I2S_CAPS: 614 cfg->i2s_caps.i2s_version = tlv->value[0]; 615 size = tlv->value[1]; 616 cfg->i2s_caps.ctrl_count = size; 617 if (!size) 618 break; 619 620 /* Multiply to get entire array size. */ 621 size *= sizeof(*cfg->i2s_caps.ctrl_base_addr); 622 cfg->i2s_caps.ctrl_base_addr = devm_kmemdup(adev->dev, 623 &tlv->value[2], 624 size, GFP_KERNEL); 625 if (!cfg->i2s_caps.ctrl_base_addr) { 626 ret = -ENOMEM; 627 goto exit; 628 } 629 break; 630 631 case AVS_HW_CFG_GATEWAY_COUNT: 632 cfg->gateway_count = *tlv->value; 633 break; 634 635 case AVS_HW_CFG_HP_EBB_COUNT: 636 cfg->hp_ebb_count = *tlv->value; 637 break; 638 639 case AVS_HW_CFG_LP_EBB_COUNT: 640 cfg->lp_ebb_count = *tlv->value; 641 break; 642 643 case AVS_HW_CFG_EBB_SIZE_BYTES: 644 cfg->ebb_size_bytes = *tlv->value; 645 break; 646 647 case AVS_HW_CFG_GPDMA_CAPS: 648 break; 649 650 default: 651 dev_info(adev->dev, "Unrecognized hw config: %d\n", tlv->type); 652 break; 653 } 654 655 offset += sizeof(*tlv) + tlv->length; 656 } 657 658 exit: 659 /* No longer needed, free it as it's owned by the get_large_config() caller. */ 660 kfree(payload); 661 return ret; 662 } 663 664 int avs_ipc_get_modules_info(struct avs_dev *adev, struct avs_mods_info **info) 665 { 666 size_t payload_size; 667 u8 *payload; 668 int ret; 669 670 ret = avs_ipc_get_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID, 671 AVS_BASEFW_MODULES_INFO, NULL, 0, 672 &payload, &payload_size); 673 if (ret) 674 return ret; 675 676 *info = (struct avs_mods_info *)payload; 677 return 0; 678 } 679 680 int avs_ipc_set_enable_logs(struct avs_dev *adev, u8 *log_info, size_t size) 681 { 682 int ret; 683 684 ret = avs_ipc_set_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID, 685 AVS_BASEFW_ENABLE_LOGS, log_info, size); 686 if (ret) 687 dev_err(adev->dev, "enable logs failed: %d\n", ret); 688 689 return ret; 690 } 691 692 int avs_ipc_set_system_time(struct avs_dev *adev) 693 { 694 struct avs_sys_time sys_time; 695 int ret; 696 u64 us; 697 698 /* firmware expects UTC time in micro seconds */ 699 us = ktime_to_us(ktime_get()); 700 sys_time.val_l = us & UINT_MAX; 701 sys_time.val_u = us >> 32; 702 703 ret = avs_ipc_set_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID, 704 AVS_BASEFW_SYSTEM_TIME, (u8 *)&sys_time, sizeof(sys_time)); 705 if (ret) 706 dev_err(adev->dev, "set system time failed: %d\n", ret); 707 708 return ret; 709 } 710 711 int avs_ipc_copier_set_sink_format(struct avs_dev *adev, u16 module_id, 712 u8 instance_id, u32 sink_id, 713 const struct avs_audio_format *src_fmt, 714 const struct avs_audio_format *sink_fmt) 715 { 716 struct avs_copier_sink_format cpr_fmt; 717 718 cpr_fmt.sink_id = sink_id; 719 /* Firmware expects driver to resend copier's input format. */ 720 cpr_fmt.src_fmt = *src_fmt; 721 cpr_fmt.sink_fmt = *sink_fmt; 722 723 return avs_ipc_set_large_config(adev, module_id, instance_id, 724 AVS_COPIER_SET_SINK_FORMAT, 725 (u8 *)&cpr_fmt, sizeof(cpr_fmt)); 726 } 727