Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 //
0003 // Copyright(c) 2021-2022 Intel Corporation. All rights reserved.
0004 //
0005 // Authors: Cezary Rojewski <cezary.rojewski@intel.com>
0006 //          Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>
0007 //
0008 
0009 #include <linux/slab.h>
0010 #include "avs.h"
0011 #include "messages.h"
0012 
0013 #define AVS_CL_TIMEOUT_MS   5000
0014 
0015 int avs_ipc_set_boot_config(struct avs_dev *adev, u32 dma_id, u32 purge)
0016 {
0017     union avs_global_msg msg = AVS_GLOBAL_REQUEST(ROM_CONTROL);
0018     struct avs_ipc_msg request = {{0}};
0019     int ret;
0020 
0021     msg.boot_cfg.rom_ctrl_msg_type = AVS_ROM_SET_BOOT_CONFIG;
0022     msg.boot_cfg.dma_id = dma_id;
0023     msg.boot_cfg.purge_request = purge;
0024     request.header = msg.val;
0025 
0026     ret = avs_dsp_send_rom_msg(adev, &request);
0027     if (ret)
0028         avs_ipc_err(adev, &request, "set boot config", ret);
0029 
0030     return ret;
0031 }
0032 
0033 int avs_ipc_load_modules(struct avs_dev *adev, u16 *mod_ids, u32 num_mod_ids)
0034 {
0035     union avs_global_msg msg = AVS_GLOBAL_REQUEST(LOAD_MULTIPLE_MODULES);
0036     struct avs_ipc_msg request;
0037     int ret;
0038 
0039     msg.load_multi_mods.mod_cnt = num_mod_ids;
0040     request.header = msg.val;
0041     request.data = mod_ids;
0042     request.size = sizeof(*mod_ids) * num_mod_ids;
0043 
0044     ret = avs_dsp_send_msg_timeout(adev, &request, NULL, AVS_CL_TIMEOUT_MS);
0045     if (ret)
0046         avs_ipc_err(adev, &request, "load multiple modules", ret);
0047 
0048     return ret;
0049 }
0050 
0051 int avs_ipc_unload_modules(struct avs_dev *adev, u16 *mod_ids, u32 num_mod_ids)
0052 {
0053     union avs_global_msg msg = AVS_GLOBAL_REQUEST(UNLOAD_MULTIPLE_MODULES);
0054     struct avs_ipc_msg request;
0055     int ret;
0056 
0057     msg.load_multi_mods.mod_cnt = num_mod_ids;
0058     request.header = msg.val;
0059     request.data = mod_ids;
0060     request.size = sizeof(*mod_ids) * num_mod_ids;
0061 
0062     ret = avs_dsp_send_msg(adev, &request, NULL);
0063     if (ret)
0064         avs_ipc_err(adev, &request, "unload multiple modules", ret);
0065 
0066     return ret;
0067 }
0068 
0069 int avs_ipc_load_library(struct avs_dev *adev, u32 dma_id, u32 lib_id)
0070 {
0071     union avs_global_msg msg = AVS_GLOBAL_REQUEST(LOAD_LIBRARY);
0072     struct avs_ipc_msg request = {{0}};
0073     int ret;
0074 
0075     msg.load_lib.dma_id = dma_id;
0076     msg.load_lib.lib_id = lib_id;
0077     request.header = msg.val;
0078 
0079     ret = avs_dsp_send_msg_timeout(adev, &request, NULL, AVS_CL_TIMEOUT_MS);
0080     if (ret)
0081         avs_ipc_err(adev, &request, "load library", ret);
0082 
0083     return ret;
0084 }
0085 
0086 int avs_ipc_create_pipeline(struct avs_dev *adev, u16 req_size, u8 priority,
0087                 u8 instance_id, bool lp, u16 attributes)
0088 {
0089     union avs_global_msg msg = AVS_GLOBAL_REQUEST(CREATE_PIPELINE);
0090     struct avs_ipc_msg request = {{0}};
0091     int ret;
0092 
0093     msg.create_ppl.ppl_mem_size = req_size;
0094     msg.create_ppl.ppl_priority = priority;
0095     msg.create_ppl.instance_id = instance_id;
0096     msg.ext.create_ppl.lp = lp;
0097     msg.ext.create_ppl.attributes = attributes;
0098     request.header = msg.val;
0099 
0100     ret = avs_dsp_send_msg(adev, &request, NULL);
0101     if (ret)
0102         avs_ipc_err(adev, &request, "create pipeline", ret);
0103 
0104     return ret;
0105 }
0106 
0107 int avs_ipc_delete_pipeline(struct avs_dev *adev, u8 instance_id)
0108 {
0109     union avs_global_msg msg = AVS_GLOBAL_REQUEST(DELETE_PIPELINE);
0110     struct avs_ipc_msg request = {{0}};
0111     int ret;
0112 
0113     msg.ppl.instance_id = instance_id;
0114     request.header = msg.val;
0115 
0116     ret = avs_dsp_send_msg(adev, &request, NULL);
0117     if (ret)
0118         avs_ipc_err(adev, &request, "delete pipeline", ret);
0119 
0120     return ret;
0121 }
0122 
0123 int avs_ipc_set_pipeline_state(struct avs_dev *adev, u8 instance_id,
0124                    enum avs_pipeline_state state)
0125 {
0126     union avs_global_msg msg = AVS_GLOBAL_REQUEST(SET_PIPELINE_STATE);
0127     struct avs_ipc_msg request = {{0}};
0128     int ret;
0129 
0130     msg.set_ppl_state.ppl_id = instance_id;
0131     msg.set_ppl_state.state = state;
0132     request.header = msg.val;
0133 
0134     ret = avs_dsp_send_msg(adev, &request, NULL);
0135     if (ret)
0136         avs_ipc_err(adev, &request, "set pipeline state", ret);
0137 
0138     return ret;
0139 }
0140 
0141 int avs_ipc_get_pipeline_state(struct avs_dev *adev, u8 instance_id,
0142                    enum avs_pipeline_state *state)
0143 {
0144     union avs_global_msg msg = AVS_GLOBAL_REQUEST(GET_PIPELINE_STATE);
0145     struct avs_ipc_msg request = {{0}};
0146     struct avs_ipc_msg reply = {{0}};
0147     int ret;
0148 
0149     msg.get_ppl_state.ppl_id = instance_id;
0150     request.header = msg.val;
0151 
0152     ret = avs_dsp_send_msg(adev, &request, &reply);
0153     if (ret) {
0154         avs_ipc_err(adev, &request, "get pipeline state", ret);
0155         return ret;
0156     }
0157 
0158     *state = reply.rsp.ext.get_ppl_state.state;
0159     return ret;
0160 }
0161 
0162 /*
0163  * avs_ipc_init_instance - Initialize module instance
0164  *
0165  * @adev: Driver context
0166  * @module_id: Module-type id
0167  * @instance_id: Unique module instance id
0168  * @ppl_id: Parent pipeline id
0169  * @core_id: DSP core to allocate module on
0170  * @domain: Processing domain (low latency or data processing)
0171  * @param: Module-type specific configuration
0172  * @param_size: Size of @param in bytes
0173  *
0174  * Argument verification, as well as pipeline state checks are done by the
0175  * firmware.
0176  *
0177  * Note: @ppl_id and @core_id are independent of each other as single pipeline
0178  * can be composed of module instances located on different DSP cores.
0179  */
0180 int avs_ipc_init_instance(struct avs_dev *adev, u16 module_id, u8 instance_id,
0181               u8 ppl_id, u8 core_id, u8 domain,
0182               void *param, u32 param_size)
0183 {
0184     union avs_module_msg msg = AVS_MODULE_REQUEST(INIT_INSTANCE);
0185     struct avs_ipc_msg request;
0186     int ret;
0187 
0188     msg.module_id = module_id;
0189     msg.instance_id = instance_id;
0190     /* firmware expects size provided in dwords */
0191     msg.ext.init_instance.param_block_size = DIV_ROUND_UP(param_size, sizeof(u32));
0192     msg.ext.init_instance.ppl_instance_id = ppl_id;
0193     msg.ext.init_instance.core_id = core_id;
0194     msg.ext.init_instance.proc_domain = domain;
0195 
0196     request.header = msg.val;
0197     request.data = param;
0198     request.size = param_size;
0199 
0200     ret = avs_dsp_send_msg(adev, &request, NULL);
0201     if (ret)
0202         avs_ipc_err(adev, &request, "init instance", ret);
0203 
0204     return ret;
0205 }
0206 
0207 /*
0208  * avs_ipc_delete_instance - Delete module instance
0209  *
0210  * @adev: Driver context
0211  * @module_id: Module-type id
0212  * @instance_id: Unique module instance id
0213  *
0214  * Argument verification, as well as pipeline state checks are done by the
0215  * firmware.
0216  *
0217  * Note: only standalone modules i.e. without a parent pipeline shall be
0218  * deleted using this IPC message. In all other cases, pipeline owning the
0219  * modules performs cleanup automatically when it is deleted.
0220  */
0221 int avs_ipc_delete_instance(struct avs_dev *adev, u16 module_id, u8 instance_id)
0222 {
0223     union avs_module_msg msg = AVS_MODULE_REQUEST(DELETE_INSTANCE);
0224     struct avs_ipc_msg request = {{0}};
0225     int ret;
0226 
0227     msg.module_id = module_id;
0228     msg.instance_id = instance_id;
0229     request.header = msg.val;
0230 
0231     ret = avs_dsp_send_msg(adev, &request, NULL);
0232     if (ret)
0233         avs_ipc_err(adev, &request, "delete instance", ret);
0234 
0235     return ret;
0236 }
0237 
0238 /*
0239  * avs_ipc_bind - Bind two module instances
0240  *
0241  * @adev: Driver context
0242  * @module_id: Source module-type id
0243  * @instance_id: Source module instance id
0244  * @dst_module_id: Sink module-type id
0245  * @dst_instance_id: Sink module instance id
0246  * @dst_queue: Sink module pin to bind @src_queue with
0247  * @src_queue: Source module pin to bind @dst_queue with
0248  */
0249 int avs_ipc_bind(struct avs_dev *adev, u16 module_id, u8 instance_id,
0250          u16 dst_module_id, u8 dst_instance_id,
0251          u8 dst_queue, u8 src_queue)
0252 {
0253     union avs_module_msg msg = AVS_MODULE_REQUEST(BIND);
0254     struct avs_ipc_msg request = {{0}};
0255     int ret;
0256 
0257     msg.module_id = module_id;
0258     msg.instance_id = instance_id;
0259     msg.ext.bind_unbind.dst_module_id = dst_module_id;
0260     msg.ext.bind_unbind.dst_instance_id = dst_instance_id;
0261     msg.ext.bind_unbind.dst_queue = dst_queue;
0262     msg.ext.bind_unbind.src_queue = src_queue;
0263     request.header = msg.val;
0264 
0265     ret = avs_dsp_send_msg(adev, &request, NULL);
0266     if (ret)
0267         avs_ipc_err(adev, &request, "bind modules", ret);
0268 
0269     return ret;
0270 }
0271 
0272 /*
0273  * avs_ipc_unbind - Unbind two module instances
0274  *
0275  * @adev: Driver context
0276  * @module_id: Source module-type id
0277  * @instance_id: Source module instance id
0278  * @dst_module_id: Sink module-type id
0279  * @dst_instance_id: Sink module instance id
0280  * @dst_queue: Sink module pin to unbind @src_queue from
0281  * @src_queue: Source module pin to unbind @dst_queue from
0282  */
0283 int avs_ipc_unbind(struct avs_dev *adev, u16 module_id, u8 instance_id,
0284            u16 dst_module_id, u8 dst_instance_id,
0285            u8 dst_queue, u8 src_queue)
0286 {
0287     union avs_module_msg msg = AVS_MODULE_REQUEST(UNBIND);
0288     struct avs_ipc_msg request = {{0}};
0289     int ret;
0290 
0291     msg.module_id = module_id;
0292     msg.instance_id = instance_id;
0293     msg.ext.bind_unbind.dst_module_id = dst_module_id;
0294     msg.ext.bind_unbind.dst_instance_id = dst_instance_id;
0295     msg.ext.bind_unbind.dst_queue = dst_queue;
0296     msg.ext.bind_unbind.src_queue = src_queue;
0297     request.header = msg.val;
0298 
0299     ret = avs_dsp_send_msg(adev, &request, NULL);
0300     if (ret)
0301         avs_ipc_err(adev, &request, "unbind modules", ret);
0302 
0303     return ret;
0304 }
0305 
0306 static int __avs_ipc_set_large_config(struct avs_dev *adev, u16 module_id, u8 instance_id,
0307                       u8 param_id, bool init_block, bool final_block,
0308                       u8 *request_data, size_t request_size, size_t off_size)
0309 {
0310     union avs_module_msg msg = AVS_MODULE_REQUEST(LARGE_CONFIG_SET);
0311     struct avs_ipc_msg request;
0312     int ret;
0313 
0314     msg.module_id = module_id;
0315     msg.instance_id = instance_id;
0316     msg.ext.large_config.data_off_size = off_size;
0317     msg.ext.large_config.large_param_id = param_id;
0318     msg.ext.large_config.final_block = final_block;
0319     msg.ext.large_config.init_block = init_block;
0320 
0321     request.header = msg.val;
0322     request.data = request_data;
0323     request.size = request_size;
0324 
0325     ret = avs_dsp_send_msg(adev, &request, NULL);
0326     if (ret)
0327         avs_ipc_err(adev, &request, "large config set", ret);
0328 
0329     return ret;
0330 }
0331 
0332 int avs_ipc_set_large_config(struct avs_dev *adev, u16 module_id,
0333                  u8 instance_id, u8 param_id,
0334                  u8 *request, size_t request_size)
0335 {
0336     size_t remaining, tx_size;
0337     bool final;
0338     int ret;
0339 
0340     remaining = request_size;
0341     tx_size = min_t(size_t, AVS_MAILBOX_SIZE, remaining);
0342     final = (tx_size == remaining);
0343 
0344     /* Initial request states total payload size. */
0345     ret = __avs_ipc_set_large_config(adev, module_id, instance_id,
0346                      param_id, 1, final, request, tx_size,
0347                      request_size);
0348     if (ret)
0349         return ret;
0350 
0351     remaining -= tx_size;
0352 
0353     /* Loop the rest only when payload exceeds mailbox's size. */
0354     while (remaining) {
0355         size_t offset;
0356 
0357         offset = request_size - remaining;
0358         tx_size = min_t(size_t, AVS_MAILBOX_SIZE, remaining);
0359         final = (tx_size == remaining);
0360 
0361         ret = __avs_ipc_set_large_config(adev, module_id, instance_id,
0362                          param_id, 0, final,
0363                          request + offset, tx_size,
0364                          offset);
0365         if (ret)
0366             return ret;
0367 
0368         remaining -= tx_size;
0369     }
0370 
0371     return 0;
0372 }
0373 
0374 int avs_ipc_get_large_config(struct avs_dev *adev, u16 module_id, u8 instance_id,
0375                  u8 param_id, u8 *request_data, size_t request_size,
0376                  u8 **reply_data, size_t *reply_size)
0377 {
0378     union avs_module_msg msg = AVS_MODULE_REQUEST(LARGE_CONFIG_GET);
0379     struct avs_ipc_msg request;
0380     struct avs_ipc_msg reply = {{0}};
0381     void *buf;
0382     int ret;
0383 
0384     reply.data = kzalloc(AVS_MAILBOX_SIZE, GFP_KERNEL);
0385     if (!reply.data)
0386         return -ENOMEM;
0387 
0388     msg.module_id = module_id;
0389     msg.instance_id = instance_id;
0390     msg.ext.large_config.data_off_size = request_size;
0391     msg.ext.large_config.large_param_id = param_id;
0392     /* final_block is always 0 on request. Updated by fw on reply. */
0393     msg.ext.large_config.final_block = 0;
0394     msg.ext.large_config.init_block = 1;
0395 
0396     request.header = msg.val;
0397     request.data = request_data;
0398     request.size = request_size;
0399     reply.size = AVS_MAILBOX_SIZE;
0400 
0401     ret = avs_dsp_send_msg(adev, &request, &reply);
0402     if (ret) {
0403         avs_ipc_err(adev, &request, "large config get", ret);
0404         kfree(reply.data);
0405         return ret;
0406     }
0407 
0408     buf = krealloc(reply.data, reply.size, GFP_KERNEL);
0409     if (!buf) {
0410         kfree(reply.data);
0411         return -ENOMEM;
0412     }
0413 
0414     *reply_data = buf;
0415     *reply_size = reply.size;
0416 
0417     return 0;
0418 }
0419 
0420 int avs_ipc_set_dx(struct avs_dev *adev, u32 core_mask, bool powerup)
0421 {
0422     union avs_module_msg msg = AVS_MODULE_REQUEST(SET_DX);
0423     struct avs_ipc_msg request;
0424     struct avs_dxstate_info dx;
0425     int ret;
0426 
0427     dx.core_mask = core_mask;
0428     dx.dx_mask = powerup ? core_mask : 0;
0429     request.header = msg.val;
0430     request.data = &dx;
0431     request.size = sizeof(dx);
0432 
0433     ret = avs_dsp_send_pm_msg(adev, &request, NULL, true);
0434     if (ret)
0435         avs_ipc_err(adev, &request, "set dx", ret);
0436 
0437     return ret;
0438 }
0439 
0440 /*
0441  * avs_ipc_set_d0ix - Set power gating policy (entering D0IX substates)
0442  *
0443  * @enable_pg: Whether to enable or disable power gating
0444  * @streaming: Whether a stream is running when transitioning
0445  */
0446 int avs_ipc_set_d0ix(struct avs_dev *adev, bool enable_pg, bool streaming)
0447 {
0448     union avs_module_msg msg = AVS_MODULE_REQUEST(SET_D0IX);
0449     struct avs_ipc_msg request = {{0}};
0450     int ret;
0451 
0452     msg.ext.set_d0ix.wake = enable_pg;
0453     msg.ext.set_d0ix.streaming = streaming;
0454 
0455     request.header = msg.val;
0456 
0457     ret = avs_dsp_send_pm_msg(adev, &request, NULL, false);
0458     if (ret)
0459         avs_ipc_err(adev, &request, "set d0ix", ret);
0460 
0461     return ret;
0462 }
0463 
0464 int avs_ipc_get_fw_config(struct avs_dev *adev, struct avs_fw_cfg *cfg)
0465 {
0466     struct avs_tlv *tlv;
0467     size_t payload_size;
0468     size_t offset = 0;
0469     u8 *payload;
0470     int ret;
0471 
0472     ret = avs_ipc_get_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
0473                        AVS_BASEFW_FIRMWARE_CONFIG, NULL, 0,
0474                        &payload, &payload_size);
0475     if (ret)
0476         return ret;
0477     /* Non-zero payload expected for FIRMWARE_CONFIG. */
0478     if (!payload_size)
0479         return -EREMOTEIO;
0480 
0481     while (offset < payload_size) {
0482         tlv = (struct avs_tlv *)(payload + offset);
0483 
0484         switch (tlv->type) {
0485         case AVS_FW_CFG_FW_VERSION:
0486             memcpy(&cfg->fw_version, tlv->value, sizeof(cfg->fw_version));
0487             break;
0488 
0489         case AVS_FW_CFG_MEMORY_RECLAIMED:
0490             cfg->memory_reclaimed = *tlv->value;
0491             break;
0492 
0493         case AVS_FW_CFG_SLOW_CLOCK_FREQ_HZ:
0494             cfg->slow_clock_freq_hz = *tlv->value;
0495             break;
0496 
0497         case AVS_FW_CFG_FAST_CLOCK_FREQ_HZ:
0498             cfg->fast_clock_freq_hz = *tlv->value;
0499             break;
0500 
0501         case AVS_FW_CFG_ALH_SUPPORT_LEVEL:
0502             cfg->alh_support = *tlv->value;
0503             break;
0504 
0505         case AVS_FW_CFG_IPC_DL_MAILBOX_BYTES:
0506             cfg->ipc_dl_mailbox_bytes = *tlv->value;
0507             break;
0508 
0509         case AVS_FW_CFG_IPC_UL_MAILBOX_BYTES:
0510             cfg->ipc_ul_mailbox_bytes = *tlv->value;
0511             break;
0512 
0513         case AVS_FW_CFG_TRACE_LOG_BYTES:
0514             cfg->trace_log_bytes = *tlv->value;
0515             break;
0516 
0517         case AVS_FW_CFG_MAX_PPL_COUNT:
0518             cfg->max_ppl_count = *tlv->value;
0519             break;
0520 
0521         case AVS_FW_CFG_MAX_ASTATE_COUNT:
0522             cfg->max_astate_count = *tlv->value;
0523             break;
0524 
0525         case AVS_FW_CFG_MAX_MODULE_PIN_COUNT:
0526             cfg->max_module_pin_count = *tlv->value;
0527             break;
0528 
0529         case AVS_FW_CFG_MODULES_COUNT:
0530             cfg->modules_count = *tlv->value;
0531             break;
0532 
0533         case AVS_FW_CFG_MAX_MOD_INST_COUNT:
0534             cfg->max_mod_inst_count = *tlv->value;
0535             break;
0536 
0537         case AVS_FW_CFG_MAX_LL_TASKS_PER_PRI_COUNT:
0538             cfg->max_ll_tasks_per_pri_count = *tlv->value;
0539             break;
0540 
0541         case AVS_FW_CFG_LL_PRI_COUNT:
0542             cfg->ll_pri_count = *tlv->value;
0543             break;
0544 
0545         case AVS_FW_CFG_MAX_DP_TASKS_COUNT:
0546             cfg->max_dp_tasks_count = *tlv->value;
0547             break;
0548 
0549         case AVS_FW_CFG_MAX_LIBS_COUNT:
0550             cfg->max_libs_count = *tlv->value;
0551             break;
0552 
0553         case AVS_FW_CFG_XTAL_FREQ_HZ:
0554             cfg->xtal_freq_hz = *tlv->value;
0555             break;
0556 
0557         case AVS_FW_CFG_POWER_GATING_POLICY:
0558             cfg->power_gating_policy = *tlv->value;
0559             break;
0560 
0561         /* Known but not useful to us. */
0562         case AVS_FW_CFG_DMA_BUFFER_CONFIG:
0563         case AVS_FW_CFG_SCHEDULER_CONFIG:
0564         case AVS_FW_CFG_CLOCKS_CONFIG:
0565         case AVS_FW_CFG_RESERVED:
0566             break;
0567 
0568         default:
0569             dev_info(adev->dev, "Unrecognized fw param: %d\n", tlv->type);
0570             break;
0571         }
0572 
0573         offset += sizeof(*tlv) + tlv->length;
0574     }
0575 
0576     /* No longer needed, free it as it's owned by the get_large_config() caller. */
0577     kfree(payload);
0578     return ret;
0579 }
0580 
0581 int avs_ipc_get_hw_config(struct avs_dev *adev, struct avs_hw_cfg *cfg)
0582 {
0583     struct avs_tlv *tlv;
0584     size_t payload_size;
0585     size_t size, offset = 0;
0586     u8 *payload;
0587     int ret;
0588 
0589     ret = avs_ipc_get_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
0590                        AVS_BASEFW_HARDWARE_CONFIG, NULL, 0,
0591                        &payload, &payload_size);
0592     if (ret)
0593         return ret;
0594     /* Non-zero payload expected for HARDWARE_CONFIG. */
0595     if (!payload_size)
0596         return -EREMOTEIO;
0597 
0598     while (offset < payload_size) {
0599         tlv = (struct avs_tlv *)(payload + offset);
0600 
0601         switch (tlv->type) {
0602         case AVS_HW_CFG_AVS_VER:
0603             cfg->avs_version = *tlv->value;
0604             break;
0605 
0606         case AVS_HW_CFG_DSP_CORES:
0607             cfg->dsp_cores = *tlv->value;
0608             break;
0609 
0610         case AVS_HW_CFG_MEM_PAGE_BYTES:
0611             cfg->mem_page_bytes = *tlv->value;
0612             break;
0613 
0614         case AVS_HW_CFG_TOTAL_PHYS_MEM_PAGES:
0615             cfg->total_phys_mem_pages = *tlv->value;
0616             break;
0617 
0618         case AVS_HW_CFG_I2S_CAPS:
0619             cfg->i2s_caps.i2s_version = tlv->value[0];
0620             size = tlv->value[1];
0621             cfg->i2s_caps.ctrl_count = size;
0622             if (!size)
0623                 break;
0624 
0625             /* Multiply to get entire array size. */
0626             size *= sizeof(*cfg->i2s_caps.ctrl_base_addr);
0627             cfg->i2s_caps.ctrl_base_addr = devm_kmemdup(adev->dev,
0628                                     &tlv->value[2],
0629                                     size, GFP_KERNEL);
0630             if (!cfg->i2s_caps.ctrl_base_addr) {
0631                 ret = -ENOMEM;
0632                 goto exit;
0633             }
0634             break;
0635 
0636         case AVS_HW_CFG_GATEWAY_COUNT:
0637             cfg->gateway_count = *tlv->value;
0638             break;
0639 
0640         case AVS_HW_CFG_HP_EBB_COUNT:
0641             cfg->hp_ebb_count = *tlv->value;
0642             break;
0643 
0644         case AVS_HW_CFG_LP_EBB_COUNT:
0645             cfg->lp_ebb_count = *tlv->value;
0646             break;
0647 
0648         case AVS_HW_CFG_EBB_SIZE_BYTES:
0649             cfg->ebb_size_bytes = *tlv->value;
0650             break;
0651 
0652         case AVS_HW_CFG_GPDMA_CAPS:
0653             break;
0654 
0655         default:
0656             dev_info(adev->dev, "Unrecognized hw config: %d\n", tlv->type);
0657             break;
0658         }
0659 
0660         offset += sizeof(*tlv) + tlv->length;
0661     }
0662 
0663 exit:
0664     /* No longer needed, free it as it's owned by the get_large_config() caller. */
0665     kfree(payload);
0666     return ret;
0667 }
0668 
0669 int avs_ipc_get_modules_info(struct avs_dev *adev, struct avs_mods_info **info)
0670 {
0671     size_t payload_size;
0672     u8 *payload;
0673     int ret;
0674 
0675     ret = avs_ipc_get_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
0676                        AVS_BASEFW_MODULES_INFO, NULL, 0,
0677                        &payload, &payload_size);
0678     if (ret)
0679         return ret;
0680     /* Non-zero payload expected for MODULES_INFO. */
0681     if (!payload_size)
0682         return -EREMOTEIO;
0683 
0684     *info = (struct avs_mods_info *)payload;
0685     return 0;
0686 }
0687 
0688 int avs_ipc_set_enable_logs(struct avs_dev *adev, u8 *log_info, size_t size)
0689 {
0690     int ret;
0691 
0692     ret = avs_ipc_set_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
0693                        AVS_BASEFW_ENABLE_LOGS, log_info, size);
0694     if (ret)
0695         dev_err(adev->dev, "enable logs failed: %d\n", ret);
0696 
0697     return ret;
0698 }
0699 
0700 int avs_ipc_set_system_time(struct avs_dev *adev)
0701 {
0702     struct avs_sys_time sys_time;
0703     int ret;
0704     u64 us;
0705 
0706     /* firmware expects UTC time in micro seconds */
0707     us = ktime_to_us(ktime_get());
0708     sys_time.val_l = us & UINT_MAX;
0709     sys_time.val_u = us >> 32;
0710 
0711     ret = avs_ipc_set_large_config(adev, AVS_BASEFW_MOD_ID, AVS_BASEFW_INST_ID,
0712                        AVS_BASEFW_SYSTEM_TIME, (u8 *)&sys_time, sizeof(sys_time));
0713     if (ret)
0714         dev_err(adev->dev, "set system time failed: %d\n", ret);
0715 
0716     return ret;
0717 }
0718 
0719 int avs_ipc_copier_set_sink_format(struct avs_dev *adev, u16 module_id,
0720                    u8 instance_id, u32 sink_id,
0721                    const struct avs_audio_format *src_fmt,
0722                    const struct avs_audio_format *sink_fmt)
0723 {
0724     struct avs_copier_sink_format cpr_fmt;
0725 
0726     cpr_fmt.sink_id = sink_id;
0727     /* Firmware expects driver to resend copier's input format. */
0728     cpr_fmt.src_fmt = *src_fmt;
0729     cpr_fmt.sink_fmt = *sink_fmt;
0730 
0731     return avs_ipc_set_large_config(adev, module_id, instance_id,
0732                     AVS_COPIER_SET_SINK_FORMAT,
0733                     (u8 *)&cpr_fmt, sizeof(cpr_fmt));
0734 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!