// SPDX-License-Identifier: GPL-2.0-only /* * skl-topology.c - Implements Platform component ALSA controls/widget * handlers. * * Copyright (C) 2014-2015 Intel Corp * Author: Jeeja KP <[email protected]> * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ #include <linux/slab.h> #include <linux/types.h> #include <linux/firmware.h> #include <linux/uuid.h> #include <sound/intel-nhlt.h> #include <sound/soc.h> #include <sound/soc-acpi.h> #include <sound/soc-topology.h> #include <uapi/sound/snd_sst_tokens.h> #include <uapi/sound/skl-tplg-interface.h> #include "skl-sst-dsp.h" #include "skl-sst-ipc.h" #include "skl-topology.h" #include "skl.h" #include "../common/sst-dsp.h" #include "../common/sst-dsp-priv.h" #define SKL_CH_FIXUP_MASK … #define SKL_RATE_FIXUP_MASK … #define SKL_FMT_FIXUP_MASK … #define SKL_IN_DIR_BIT_MASK … #define SKL_PIN_COUNT_MASK … static const int mic_mono_list[] = …; static const int mic_stereo_list[][SKL_CH_STEREO] = …; static const int mic_trio_list[][SKL_CH_TRIO] = …; static const int mic_quatro_list[][SKL_CH_QUATRO] = …; #define CHECK_HW_PARAMS(ch, freq, bps, prm_ch, prm_freq, prm_bps) … void skl_tplg_d0i3_get(struct skl_dev *skl, enum d0i3_capability caps) { … } void skl_tplg_d0i3_put(struct skl_dev *skl, enum d0i3_capability caps) { … } /* * SKL DSP driver modelling uses only few DAPM widgets so for rest we will * ignore. This helpers checks if the SKL driver handles this widget type */ static int is_skl_dsp_widget_type(struct snd_soc_dapm_widget *w, struct device *dev) { … } static void skl_dump_mconfig(struct skl_dev *skl, struct skl_module_cfg *mcfg) { … } static void skl_tplg_update_chmap(struct skl_module_fmt *fmt, int chs) { … } static void skl_tplg_update_params(struct skl_module_fmt *fmt, struct skl_pipe_params *params, int fixup) { … } /* * A pipeline may have modules which impact the pcm parameters, like SRC, * channel converter, format converter. * We need to calculate the output params by applying the 'fixup' * Topology will tell driver which type of fixup is to be applied by * supplying the fixup mask, so based on that we calculate the output * * Now In FE the pcm hw_params is source/target format. Same is applicable * for BE with its hw_params invoked. * here based on FE, BE pipeline and direction we calculate the input and * outfix and then apply that for a module */ static void skl_tplg_update_params_fixup(struct skl_module_cfg *m_cfg, struct skl_pipe_params *params, bool is_fe) { … } /* * A module needs input and output buffers, which are dependent upon pcm * params, so once we have calculate params, we need buffer calculation as * well. */ static void skl_tplg_update_buffer_size(struct skl_dev *skl, struct skl_module_cfg *mcfg) { … } static u8 skl_tplg_be_dev_type(int dev_type) { … } static int skl_tplg_update_be_blob(struct snd_soc_dapm_widget *w, struct skl_dev *skl) { … } static void skl_tplg_update_module_params(struct snd_soc_dapm_widget *w, struct skl_dev *skl) { … } /* * some modules can have multiple params set from user control and * need to be set after module is initialized. If set_param flag is * set module params will be done after module is initialised. */ static int skl_tplg_set_module_params(struct snd_soc_dapm_widget *w, struct skl_dev *skl) { … } /* * some module param can set from user control and this is required as * when module is initailzed. if module param is required in init it is * identifed by set_param flag. if set_param flag is not set, then this * parameter needs to set as part of module init. */ static int skl_tplg_set_module_init_data(struct snd_soc_dapm_widget *w) { … } static int skl_tplg_module_prepare(struct skl_dev *skl, struct skl_pipe *pipe, struct snd_soc_dapm_widget *w, struct skl_module_cfg *mcfg) { … } /* * Inside a pipe instance, we can have various modules. These modules need * to instantiated in DSP by invoking INIT_MODULE IPC, which is achieved by * skl_init_module() routine, so invoke that for all modules in a pipeline */ static int skl_tplg_init_pipe_modules(struct skl_dev *skl, struct skl_pipe *pipe) { … } static int skl_tplg_unload_pipe_modules(struct skl_dev *skl, struct skl_pipe *pipe) { … } static void skl_tplg_set_pipe_config_idx(struct skl_pipe *pipe, int idx) { … } /* * Here, we select pipe format based on the pipe type and pipe * direction to determine the current config index for the pipeline. * The config index is then used to select proper module resources. * Intermediate pipes currently have a fixed format hence we select the * 0th configuratation by default for such pipes. */ static int skl_tplg_get_pipe_config(struct skl_dev *skl, struct skl_module_cfg *mconfig) { … } /* * Mixer module represents a pipeline. So in the Pre-PMU event of mixer we * need create the pipeline. So we do following: * - Create the pipeline * - Initialize the modules in pipeline * - finally bind all modules together */ static int skl_tplg_mixer_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w, struct skl_dev *skl) { … } static int skl_fill_sink_instance_id(struct skl_dev *skl, u32 *params, int size, struct skl_module_cfg *mcfg) { … } /* * Some modules require params to be set after the module is bound to * all pins connected. * * The module provider initializes set_param flag for such modules and we * send params after binding */ static int skl_tplg_set_module_bind_params(struct snd_soc_dapm_widget *w, struct skl_module_cfg *mcfg, struct skl_dev *skl) { … } static int skl_get_module_id(struct skl_dev *skl, guid_t *uuid) { … } static int skl_tplg_find_moduleid_from_uuid(struct skl_dev *skl, const struct snd_kcontrol_new *k) { … } /* * Retrieve the module id from UUID mentioned in the * post bind params */ void skl_tplg_add_moduleid_in_bind_params(struct skl_dev *skl, struct snd_soc_dapm_widget *w) { … } static int skl_tplg_module_add_deferred_bind(struct skl_dev *skl, struct skl_module_cfg *src, struct skl_module_cfg *dst) { … } static int skl_tplg_bind_sinks(struct snd_soc_dapm_widget *w, struct skl_dev *skl, struct snd_soc_dapm_widget *src_w, struct skl_module_cfg *src_mconfig) { … } /* * A PGA represents a module in a pipeline. So in the Pre-PMU event of PGA * we need to do following: * - Bind to sink pipeline * Since the sink pipes can be running and we don't get mixer event on * connect for already running mixer, we need to find the sink pipes * here and bind to them. This way dynamic connect works. * - Start sink pipeline, if not running * - Then run current pipe */ static int skl_tplg_pga_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w, struct skl_dev *skl) { … } static struct snd_soc_dapm_widget *skl_get_src_dsp_widget( struct snd_soc_dapm_widget *w, struct skl_dev *skl) { … } /* * in the Post-PMU event of mixer we need to do following: * - Check if this pipe is running * - if not, then * - bind this pipeline to its source pipeline * if source pipe is already running, this means it is a dynamic * connection and we need to bind only to that pipe * - start this pipeline */ static int skl_tplg_mixer_dapm_post_pmu_event(struct snd_soc_dapm_widget *w, struct skl_dev *skl) { … } /* * in the Pre-PMD event of mixer we need to do following: * - Stop the pipe * - find the source connections and remove that from dapm_path_list * - unbind with source pipelines if still connected */ static int skl_tplg_mixer_dapm_pre_pmd_event(struct snd_soc_dapm_widget *w, struct skl_dev *skl) { … } /* * in the Post-PMD event of mixer we need to do following: * - Unbind the modules within the pipeline * - Delete the pipeline (modules are not required to be explicitly * deleted, pipeline delete is enough here */ static int skl_tplg_mixer_dapm_post_pmd_event(struct snd_soc_dapm_widget *w, struct skl_dev *skl) { … } /* * in the Post-PMD event of PGA we need to do following: * - Stop the pipeline * - In source pipe is connected, unbind with source pipelines */ static int skl_tplg_pga_dapm_post_pmd_event(struct snd_soc_dapm_widget *w, struct skl_dev *skl) { … } /* * In modelling, we assume there will be ONLY one mixer in a pipeline. If a * second one is required that is created as another pipe entity. * The mixer is responsible for pipe management and represent a pipeline * instance */ static int skl_tplg_mixer_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *k, int event) { … } /* * In modelling, we assumed rest of the modules in pipeline are PGA. But we * are interested in last PGA (leaf PGA) in a pipeline to disconnect with * the sink when it is running (two FE to one BE or one FE to two BE) * scenarios */ static int skl_tplg_pga_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *k, int event) { … } static int skl_tplg_multi_config_set_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol, bool is_set) { … } static int skl_tplg_multi_config_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { … } static int skl_tplg_multi_config_set(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { … } static int skl_tplg_multi_config_get_dmic(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { … } static int skl_tplg_multi_config_set_dmic(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { … } static int skl_tplg_tlv_control_get(struct snd_kcontrol *kcontrol, unsigned int __user *data, unsigned int size) { … } #define SKL_PARAM_VENDOR_ID … static int skl_tplg_tlv_control_set(struct snd_kcontrol *kcontrol, const unsigned int __user *data, unsigned int size) { … } static int skl_tplg_mic_control_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { … } static int skl_fill_mic_sel_params(struct skl_module_cfg *mconfig, struct skl_mic_sel_config *mic_cfg, struct device *dev) { … } static int skl_tplg_mic_control_set(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { … } /* * Fill the dma id for host and link. In case of passthrough * pipeline, this will both host and link in the same * pipeline, so need to copy the link and host based on dev_type */ static void skl_tplg_fill_dma_id(struct skl_module_cfg *mcfg, struct skl_pipe_params *params) { … } /* * The FE params are passed by hw_params of the DAI. * On hw_params, the params are stored in Gateway module of the FE and we * need to calculate the format in DSP module configuration, that * conversion is done here */ int skl_tplg_update_pipe_params(struct device *dev, struct skl_module_cfg *mconfig, struct skl_pipe_params *params) { … } /* * Query the module config for the FE DAI * This is used to find the hw_params set for that DAI and apply to FE * pipeline */ struct skl_module_cfg * skl_tplg_fe_get_cpr_module(struct snd_soc_dai *dai, int stream) { … } static struct skl_module_cfg *skl_get_mconfig_pb_cpr( struct snd_soc_dai *dai, struct snd_soc_dapm_widget *w) { … } static struct skl_module_cfg *skl_get_mconfig_cap_cpr( struct snd_soc_dai *dai, struct snd_soc_dapm_widget *w) { … } struct skl_module_cfg * skl_tplg_be_get_cpr_module(struct snd_soc_dai *dai, int stream) { … } static u8 skl_tplg_be_link_type(int dev_type) { … } /* * Fill the BE gateway parameters * The BE gateway expects a blob of parameters which are kept in the ACPI * NHLT blob, so query the blob for interface type (i2s/pdm) and instance. * The port can have multiple settings so pick based on the pipeline * parameters */ static int skl_tplg_be_fill_pipe_params(struct snd_soc_dai *dai, struct skl_module_cfg *mconfig, struct skl_pipe_params *params) { … } static int skl_tplg_be_set_src_pipe_params(struct snd_soc_dai *dai, struct snd_soc_dapm_widget *w, struct skl_pipe_params *params) { … } static int skl_tplg_be_set_sink_pipe_params(struct snd_soc_dai *dai, struct snd_soc_dapm_widget *w, struct skl_pipe_params *params) { … } /* * BE hw_params can be a source parameters (capture) or sink parameters * (playback). Based on sink and source we need to either find the source * list or the sink list and set the pipeline parameters */ int skl_tplg_be_update_params(struct snd_soc_dai *dai, struct skl_pipe_params *params) { … } static const struct snd_soc_tplg_widget_events skl_tplg_widget_ops[] = …; static const struct snd_soc_tplg_bytes_ext_ops skl_tlv_ops[] = …; static const struct snd_soc_tplg_kcontrol_ops skl_tplg_kcontrol_ops[] = …; static int skl_tplg_fill_pipe_cfg(struct device *dev, struct skl_pipe *pipe, u32 tkn, u32 tkn_val, int conf_idx, int dir) { … } static int skl_tplg_fill_pipe_tkn(struct device *dev, struct skl_pipe *pipe, u32 tkn, u32 tkn_val) { … } /* * Add pipeline by parsing the relevant tokens * Return an existing pipe if the pipe already exists. */ static int skl_tplg_add_pipe(struct device *dev, struct skl_module_cfg *mconfig, struct skl_dev *skl, struct snd_soc_tplg_vendor_value_elem *tkn_elem) { … } static int skl_tplg_get_uuid(struct device *dev, guid_t *guid, struct snd_soc_tplg_vendor_uuid_elem *uuid_tkn) { … } static int skl_tplg_fill_pin(struct device *dev, struct snd_soc_tplg_vendor_value_elem *tkn_elem, struct skl_module_pin *m_pin, int pin_index) { … } /* * Parse for pin config specific tokens to fill up the * module private data */ static int skl_tplg_fill_pins_info(struct device *dev, struct skl_module_cfg *mconfig, struct snd_soc_tplg_vendor_value_elem *tkn_elem, int dir, int pin_count) { … } /* * Fill up input/output module config format based * on the direction */ static int skl_tplg_fill_fmt(struct device *dev, struct skl_module_fmt *dst_fmt, u32 tkn, u32 value) { … } static int skl_tplg_widget_fill_fmt(struct device *dev, struct skl_module_iface *fmt, u32 tkn, u32 val, u32 dir, int fmt_idx) { … } static void skl_tplg_fill_pin_dynamic_val( struct skl_module_pin *mpin, u32 pin_count, u32 value) { … } /* * Resource table in the manifest has pin specific resources * like pin and pin buffer size */ static int skl_tplg_manifest_pin_res_tkn(struct device *dev, struct snd_soc_tplg_vendor_value_elem *tkn_elem, struct skl_module_res *res, int pin_idx, int dir) { … } /* * Fill module specific resources from the manifest's resource * table like CPS, DMA size, mem_pages. */ static int skl_tplg_fill_res_tkn(struct device *dev, struct snd_soc_tplg_vendor_value_elem *tkn_elem, struct skl_module_res *res, int pin_idx, int dir) { … } /* * Parse tokens to fill up the module private data */ static int skl_tplg_get_token(struct device *dev, struct snd_soc_tplg_vendor_value_elem *tkn_elem, struct skl_dev *skl, struct skl_module_cfg *mconfig) { … } /* * Parse the vendor array for specific tokens to construct * module private data */ static int skl_tplg_get_tokens(struct device *dev, char *pvt_data, struct skl_dev *skl, struct skl_module_cfg *mconfig, int block_size) { … } /* * Every data block is preceded by a descriptor to read the number * of data blocks, they type of the block and it's size */ static int skl_tplg_get_desc_blocks(struct device *dev, struct snd_soc_tplg_vendor_array *array) { … } static int skl_tplg_get_caps_data(struct device *dev, char *data, struct skl_module_cfg *mconfig) { … } /* * Parse the private data for the token and corresponding value. * The private data can have multiple data blocks. So, a data block * is preceded by a descriptor for number of blocks and a descriptor * for the type and size of the suceeding data block. */ static int skl_tplg_get_pvt_data(struct snd_soc_tplg_dapm_widget *tplg_w, struct skl_dev *skl, struct device *dev, struct skl_module_cfg *mconfig) { … } static void skl_clear_pin_config(struct snd_soc_component *component, struct snd_soc_dapm_widget *w) { … } void skl_cleanup_resources(struct skl_dev *skl) { … } /* * Topology core widget load callback * * This is used to save the private data for each widget which gives * information to the driver about module and pipeline parameters which DSP * FW expects like ids, resource values, formats etc */ static int skl_tplg_widget_load(struct snd_soc_component *cmpnt, int index, struct snd_soc_dapm_widget *w, struct snd_soc_tplg_dapm_widget *tplg_w) { … } static int skl_init_algo_data(struct device *dev, struct soc_bytes_ext *be, struct snd_soc_tplg_bytes_control *bc) { … } static int skl_init_enum_data(struct device *dev, struct soc_enum *se, struct snd_soc_tplg_enum_control *ec) { … } static int skl_tplg_control_load(struct snd_soc_component *cmpnt, int index, struct snd_kcontrol_new *kctl, struct snd_soc_tplg_ctl_hdr *hdr) { … } static int skl_tplg_fill_str_mfest_tkn(struct device *dev, struct snd_soc_tplg_vendor_string_elem *str_elem, struct skl_dev *skl) { … } static int skl_tplg_get_str_tkn(struct device *dev, struct snd_soc_tplg_vendor_array *array, struct skl_dev *skl) { … } static int skl_tplg_manifest_fill_fmt(struct device *dev, struct skl_module_iface *fmt, struct snd_soc_tplg_vendor_value_elem *tkn_elem, u32 dir, int fmt_idx) { … } static int skl_tplg_fill_mod_info(struct device *dev, struct snd_soc_tplg_vendor_value_elem *tkn_elem, struct skl_module *mod) { … } static int skl_tplg_get_int_tkn(struct device *dev, struct snd_soc_tplg_vendor_value_elem *tkn_elem, struct skl_dev *skl) { … } /* * Fill the manifest structure by parsing the tokens based on the * type. */ static int skl_tplg_get_manifest_tkn(struct device *dev, char *pvt_data, struct skl_dev *skl, int block_size) { … } /* * Parse manifest private data for tokens. The private data block is * preceded by descriptors for type and size of data block. */ static int skl_tplg_get_manifest_data(struct snd_soc_tplg_manifest *manifest, struct device *dev, struct skl_dev *skl) { … } static int skl_manifest_load(struct snd_soc_component *cmpnt, int index, struct snd_soc_tplg_manifest *manifest) { … } static int skl_tplg_complete(struct snd_soc_component *component) { … } static const struct snd_soc_tplg_ops skl_tplg_ops = …; /* * A pipe can have multiple modules, each of them will be a DAPM widget as * well. While managing a pipeline we need to get the list of all the * widgets in a pipelines, so this helper - skl_tplg_create_pipe_widget_list() * helps to get the SKL type widgets in that pipeline */ static int skl_tplg_create_pipe_widget_list(struct snd_soc_component *component) { … } static void skl_tplg_set_pipe_type(struct skl_dev *skl, struct skl_pipe *pipe) { … } /* * SKL topology init routine */ int skl_tplg_init(struct snd_soc_component *component, struct hdac_bus *bus) { … } void skl_tplg_exit(struct snd_soc_component *component, struct hdac_bus *bus) { … }
Codebase Browser
linux