高通音频驱动录音流程（四)

最新推荐文章于 2024-07-29 00:32:45 发布
最新推荐文章于 2024-07-29 00:32:45 发布
阅读量1.5k 收藏 15
点赞数
分类专栏： C linux aarch64 文章标签： alsa linux kernel
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28217563/article/details/112652413
版权
C 同时被 3 个专栏收录
15 篇文章 0 订阅
订阅专栏
linux
10 篇文章 9 订阅
订阅专栏
aarch64
7 篇文章 0 订阅
订阅专栏

高通音频驱动录音流程（四)
Front/Back End Machine驱动注册

snd_soc_register_card


对于音频驱动，最终的目标是注册设备节点，用来对注册的kcontrol进行设置，并完成音频数据的搬运。而之前的codec驱动，platform驱动，cpu dai驱动，所作的工作并没有涉及这些，它们只是将初始化的compent挂在component_list这个链表上，而这个链表的作用，就是在之后的声卡注册过程中，根据dai_link来查找相应的compent driver和dai。
声卡的注册，是发生在machine驱动中的，根据上面的分析逻辑，这三个驱动所对应的模块加载，也是有先后顺序的，machine驱动最后加载。进行相应的初始化以后，调用snd_soc_register_card进行声卡注册。最后会调用snd_soc_instantiate_card，实例化声卡。 

/**
 * snd_soc_register_card - Register a card with the ASoC core
 *
 * @card: Card to register
 *
 */
int snd_soc_register_card(struct snd_soc_card *card)
{
	int i, ret;
	struct snd_soc_pcm_runtime *rtd;

	if (!card->name || !card->dev)
		return -EINVAL;

	for (i = 0; i < card->num_links; i++) {
		struct snd_soc_dai_link *link = &card->dai_link[i];

		ret = soc_init_dai_link(card, link);
		if (ret) {
			dev_err(card->dev, "ASoC: failed to init link %s\n",
				link->name);
			return ret;
		}
	}

	dev_set_drvdata(card->dev, card);

	snd_soc_initialize_card_lists(card);

	INIT_LIST_HEAD(&card->dai_link_list);
	card->num_dai_links = 0;

	INIT_LIST_HEAD(&card->rtd_list);
	card->num_rtd = 0;

	INIT_LIST_HEAD(&card->dapm_dirty);
	INIT_LIST_HEAD(&card->dobj_list);
	card->instantiated = 0;
	mutex_init(&card->mutex);
	mutex_init(&card->dapm_mutex);
	mutex_init(&card->dapm_power_mutex);

	ret = snd_soc_instantiate_card(card);
	if (ret != 0)
		return ret;

	/* deactivate pins to sleep state */
	list_for_each_entry(rtd, &card->rtd_list, list)  {
		struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
		int j;

		for (j = 0; j < rtd->num_codecs; j++) {
			struct snd_soc_dai *codec_dai = rtd->codec_dais[j];
			if (!codec_dai->active)
				pinctrl_pm_select_sleep_state(codec_dai->dev);
		}

		if (!cpu_dai->active)
			pinctrl_pm_select_sleep_state(cpu_dai->dev);
	}

	return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_register_card);

snd_soc_instantiate_card

snd_soc_instantiate_card完成声卡注册。完成声卡注册。主要做了如下工作：

static int snd_soc_instantiate_card(struct snd_soc_card *card)
{
	struct snd_soc_pcm_runtime *rtd;
	struct snd_soc_dai_link *dai_link;
	int ret, i, order;

	mutex_lock(&client_mutex);
	mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_INIT);

	/* check whether any platform is ignore machine FE and using topology */
	soc_check_tplg_fes(card);

	/* bind DAIs */
	for (i = 0; i < card->num_links; i++) {
		ret = soc_bind_dai_link(card, &card->dai_link[i]);
		if (ret != 0)
			goto base_error;
	}

	/* bind aux_devs too */
	for (i = 0; i < card->num_aux_devs; i++) {
		ret = soc_bind_aux_dev(card, i);
		if (ret != 0)
			goto base_error;
	}

	/* add predefined DAI links to the list */
	for (i = 0; i < card->num_links; i++)
		snd_soc_add_dai_link(card, card->dai_link+i);

	/* card bind complete so register a sound card */
	ret = snd_card_new(card->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
			card->owner, 0, &card->snd_card);
	if (ret < 0) {
		dev_err(card->dev,
			"ASoC: can't create sound card for card %s: %d\n",
			card->name, ret);
		goto base_error;
	}

	soc_init_card_debugfs(card);

	card->dapm.bias_level = SND_SOC_BIAS_OFF;
	card->dapm.dev = card->dev;
	card->dapm.card = card;
	list_add(&card->dapm.list, &card->dapm_list);

#ifdef CONFIG_DEBUG_FS
	snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);
#endif

#ifdef CONFIG_PM_SLEEP
	/* deferred resume work */
	INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
#endif

	if (card->dapm_widgets)
		snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,
					  card->num_dapm_widgets);

	if (card->of_dapm_widgets)
		snd_soc_dapm_new_controls(&card->dapm, card->of_dapm_widgets,
					  card->num_of_dapm_widgets);

	/* initialise the sound card only once */
	if (card->probe) {
		ret = card->probe(card);
		if (ret < 0)
			goto card_probe_error;
	}

	/* probe all components used by DAI links on this card */
	for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
			order++) {
		list_for_each_entry(rtd, &card->rtd_list, list) {
			ret = soc_probe_link_components(card, rtd, order);
			if (ret < 0) {
				dev_err(card->dev,
					"ASoC: failed to instantiate card %d\n",
					ret);
				goto probe_dai_err;
			}
		}
	}

	/* probe auxiliary components */
	ret = soc_probe_aux_devices(card);
	if (ret < 0)
		goto probe_dai_err;

	/* Find new DAI links added during probing components and bind them.
	 * Components with topology may bring new DAIs and DAI links.
	 */
	list_for_each_entry(dai_link, &card->dai_link_list, list) {
		if (soc_is_dai_link_bound(card, dai_link))
			continue;

		ret = soc_init_dai_link(card, dai_link);
		if (ret)
			goto probe_dai_err;
		ret = soc_bind_dai_link(card, dai_link);
		if (ret)
			goto probe_dai_err;
	}

	/* probe all DAI links on this card */
	for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
			order++) {
		list_for_each_entry(rtd, &card->rtd_list, list) {
			ret = soc_probe_link_dais(card, rtd, order);
			if (ret < 0) {
				dev_err(card->dev,
					"ASoC: failed to instantiate card %d\n",
					ret);
				goto probe_dai_err;
			}
		}
	}

	snd_soc_dapm_link_dai_widgets(card);
	snd_soc_dapm_connect_dai_link_widgets(card);

	if (card->controls)
		snd_soc_add_card_controls(card, card->controls, card->num_controls);

	if (card->dapm_routes)
		snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,
					card->num_dapm_routes);

	if (card->of_dapm_routes)
		snd_soc_dapm_add_routes(&card->dapm, card->of_dapm_routes,
					card->num_of_dapm_routes);

	/* try to set some sane longname if DMI is available */
	snd_soc_set_dmi_name(card, NULL);

	snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
		 "%s", card->name);
	snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
		 "%s", card->long_name ? card->long_name : card->name);
	snprintf(card->snd_card->driver, sizeof(card->snd_card->driver),
		 "%s", card->driver_name ? card->driver_name : card->name);
	for (i = 0; i < ARRAY_SIZE(card->snd_card->driver); i++) {
		switch (card->snd_card->driver[i]) {
		case '_':
		case '-':
		case '\0':
			break;
		default:
			if (!isalnum(card->snd_card->driver[i]))
				card->snd_card->driver[i] = '_';
			break;
		}
	}

	if (card->late_probe) {
		ret = card->late_probe(card);
		if (ret < 0) {
			dev_err(card->dev, "ASoC: %s late_probe() failed: %d\n",
				card->name, ret);
			goto probe_aux_dev_err;
		}
	}

	snd_soc_dapm_new_widgets(card);

	ret = snd_card_register(card->snd_card);
	if (ret < 0) {
		dev_err(card->dev, "ASoC: failed to register soundcard %d\n",
				ret);
		goto probe_aux_dev_err;
	}

	card->instantiated = 1;
	dapm_mark_endpoints_dirty(card);
	snd_soc_dapm_sync(&card->dapm);
	mutex_unlock(&card->mutex);
	mutex_unlock(&client_mutex);

	return 0;

probe_aux_dev_err:
	soc_remove_aux_devices(card);

probe_dai_err:
	soc_remove_dai_links(card);

card_probe_error:
	if (card->remove)
		card->remove(card);

	snd_soc_dapm_free(&card->dapm);
	soc_cleanup_card_debugfs(card);
	snd_card_free(card->snd_card);

base_error:
	soc_remove_pcm_runtimes(card);
	mutex_unlock(&card->mutex);
	mutex_unlock(&client_mutex);

	return ret;
}

soc_init_dai_link

snd_soc_init_multicodec主要对codec的dai_link配置进行检查，并将其挂载到特定的数据结构。
之后检查codec，platform，cpu dai的dai_link配置，不合规直接退出声卡注册

static int soc_init_dai_link(struct snd_soc_card *card,
				   struct snd_soc_dai_link *link)
{
	int i, ret;

	ret = snd_soc_init_multicodec(card, link);
	if (ret) {
		dev_err(card->dev, "ASoC: failed to init multicodec\n");
		return ret;
	}

	for (i = 0; i < link->num_codecs; i++) {
		/*
		 * Codec must be specified by 1 of name or OF node,
		 * not both or neither.
		 */
		if (!!link->codecs[i].name ==
		    !!link->codecs[i].of_node) {
			dev_err(card->dev, "ASoC: Neither/both codec name/of_node are set for %s\n",
				link->name);
			return -EINVAL;
		}
		/* Codec DAI name must be specified */
		if (!link->codecs[i].dai_name) {
			dev_err(card->dev, "ASoC: codec_dai_name not set for %s\n",
				link->name);
			return -EINVAL;
		}
	}

	/*
	 * Platform may be specified by either name or OF node, but
	 * can be left unspecified, and a dummy platform will be used.
	 */
	if (link->platform_name && link->platform_of_node) {
		dev_err(card->dev,
			"ASoC: Both platform name/of_node are set for %s\n",
			link->name);
		return -EINVAL;
	}

	/*
	 * CPU device may be specified by either name or OF node, but
	 * can be left unspecified, and will be matched based on DAI
	 * name alone..
	 */
	if (link->cpu_name && link->cpu_of_node) {
		dev_err(card->dev,
			"ASoC: Neither/both cpu name/of_node are set for %s\n",
			link->name);
		return -EINVAL;
	}
	/*
	 * At least one of CPU DAI name or CPU device name/node must be
	 * specified
	 */
	if (!link->cpu_dai_name &&
	    !(link->cpu_name || link->cpu_of_node)) {
		dev_err(card->dev,
			"ASoC: Neither cpu_dai_name nor cpu_name/of_node are set for %s\n",
			link->name);
		return -EINVAL;
	}

	return 0;
}

soc_bind_dai_link

在machine driver中，对于mic录音的案例来说，定义了fe与be的dai_link, 在注册声卡前，会对这两个dai_link进行处理，然后通过名称或dts node来查找之前挂在component_list上面的dai。

5634	{/* hw:x,0 */
5635		.name = MSM_DAILINK_NAME(Media1),
5636		.stream_name = "MultiMedia1",
5637		.cpu_dai_name = "MultiMedia1",
5638		.platform_name = "msm-pcm-dsp.0",
5639		.dynamic = 1,
5640		.async_ops = ASYNC_DPCM_SND_SOC_PREPARE,
5641		.dpcm_playback = 1,
5642		.dpcm_capture = 1,
5643		.trigger = {SND_SOC_DPCM_TRIGGER_POST,
5644			SND_SOC_DPCM_TRIGGER_POST},
5645		.codec_dai_name = "snd-soc-dummy-dai",
5646		.codec_name = "snd-soc-dummy",
5647		.ignore_suspend = 1,
5648		/* this dainlink has playback support */
5649		.ignore_pmdown_time = 1,
5650		.id = MSM_FRONTEND_DAI_MULTIMEDIA1
5651	},

7303	/* TX CDC DMA Backend DAI Links */
7304	{
7305		.name = LPASS_BE_TX_CDC_DMA_TX_3,
7306		.stream_name = "TX CDC DMA3 Capture",
7307		.cpu_dai_name = "msm-dai-cdc-dma-dev.45111",
7308		.platform_name = "msm-pcm-routing",
7309		.codec_name = "bolero_codec",
7310		.codec_dai_name = "tx_macro_tx1",
7311		.no_pcm = 1,
7312		.dpcm_capture = 1,
7313		.id = MSM_BACKEND_DAI_TX_CDC_DMA_TX_3,
7314		.be_hw_params_fixup = msm_be_hw_params_fixup,
7315		.ignore_suspend = 1,
7316		.ops = &msm_cdc_dma_be_ops,
7317	},

static int soc_bind_dai_link(struct snd_soc_card *card,
	struct snd_soc_dai_link *dai_link)
{
	struct snd_soc_pcm_runtime *rtd;
	struct snd_soc_dai_link_component *codecs = dai_link->codecs;
	struct snd_soc_dai_link_component cpu_dai_component;
	struct snd_soc_component *component;
	struct snd_soc_dai **codec_dais;
	struct device_node *platform_of_node;
	const char *platform_name;
	int i;

	if (dai_link->ignore)
		return 0;

	dev_dbg(card->dev, "ASoC: binding %s\n", dai_link->name);
	/* 检查这个dai linke之前是否已经被绑定 */
	if (soc_is_dai_link_bound(card, dai_link)) {
		dev_dbg(card->dev, "ASoC: dai link %s already bound\n",
			dai_link->name);
		return 0;
	}
	/* 初始化rtd，之后调用platform驱动会用到 */
	rtd = soc_new_pcm_runtime(card, dai_link);
	if (!rtd)
		return -ENOMEM;

	cpu_dai_component.name = dai_link->cpu_name;
	cpu_dai_component.of_node = dai_link->cpu_of_node;
	cpu_dai_component.dai_name = dai_link->cpu_dai_name;
	rtd->cpu_dai = snd_soc_find_dai(&cpu_dai_component);
	if (!rtd->cpu_dai) {
		dev_info(card->dev, "ASoC: CPU DAI %s not registered\n",
			 dai_link->cpu_dai_name);
		goto _err_defer;
	}
	/* 从component_list中查找对应的cpu dai，并将其挂到rtd->component_list上 */
	snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);

	rtd->num_codecs = dai_link->num_codecs;

	/* Find CODEC from registered CODECs */
	codec_dais = rtd->codec_dais;
	for (i = 0; i < rtd->num_codecs; i++) {
		codec_dais[i] = snd_soc_find_dai(&codecs[i]);
		if (!codec_dais[i]) {
			dev_err(card->dev, "ASoC: CODEC DAI %s not registered\n",
				codecs[i].dai_name);
			goto _err_defer;
		}
		snd_soc_rtdcom_add(rtd, codec_dais[i]->component);
	}

	/* Single codec links expect codec and codec_dai in runtime data */
	rtd->codec_dai = codec_dais[0];

	/* if there's no platform we match on the empty platform */
	platform_name = dai_link->platform_name;
	if (!platform_name && !dai_link->platform_of_node)
		platform_name = "snd-soc-dummy";

	/* find one from the set of registered platforms */
	list_for_each_entry(component, &component_list, list) {
		platform_of_node = component->dev->of_node;
		if (!platform_of_node && component->dev->parent->of_node)
			platform_of_node = component->dev->parent->of_node;

		if (dai_link->platform_of_node) {
			if (platform_of_node != dai_link->platform_of_node)
				continue;
		} else {
			if (strcmp(component->name, platform_name))
				continue;
		}

		snd_soc_rtdcom_add(rtd, component);
	}
	/* 将rtd添加到链表card->rtd_list */
	soc_add_pcm_runtime(card, rtd);
	return 0;

_err_defer:
	soc_free_pcm_runtime(rtd);
	return  -EPROBE_DEFER;
}

soc_bind_dai_link操作完成后，rtd_list就像下面这样：

card->rtd_list
	rtd->list
	rtd->cpu_dai
	rtd->codec_dai
	rtd->component_list
		new_rtdcom->list
			rtd->cpu_dai->component
			rtd->cpu_dai->component->driver
				component->dai_list
					cpu_dai->list
		new_rtdcom->list
			rtd->codec_dais[i]->component
			rtd->codec_dais[i]->component->driver
				component->dai_list
					codec_dais->list
		new_rtdcom->list
			platform_component[i]
				component->dai_list

soc_bind_aux_dev

绑定aux device, 在这个例子中，绑定的就是wcd9370 codec，并将其挂在card->aux_comp_list上

static int soc_bind_aux_dev(struct snd_soc_card *card, int num)
{
	struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
	struct snd_soc_component *component;
	const char *name;
	struct device_node *codec_of_node;

	if (aux_dev->codec_of_node || aux_dev->codec_name) {
		/* codecs, usually analog devices */
		name = aux_dev->codec_name;
		codec_of_node = aux_dev->codec_of_node;
		component = soc_find_component(codec_of_node, name);
		if (!component) {
			if (codec_of_node)
				name = of_node_full_name(codec_of_node);
			goto err_defer;
		}
	} else if (aux_dev->name) {
		/* generic components */
		name = aux_dev->name;
		component = soc_find_component(NULL, name);
		if (!component)
			goto err_defer;
	} else {
		dev_err(card->dev, "ASoC: Invalid auxiliary device\n");
		return -EINVAL;
	}

	component->init = aux_dev->init;
	list_add(&component->card_aux_list, &card->aux_comp_list);

	return 0;

err_defer:
	dev_err(card->dev, "ASoC: %s not registered\n", name);
	return -EPROBE_DEFER;
}

snd_soc_add_dai_link

添加预定义的声卡到相应的list

snd_card_new

创建并初始化声卡

snd_soc_dapm_new_controls

创建一个dapm controller并把它添加到dapm->card->widgets

soc_probe_link_components

soc_set_name_prefix，设置component的name prefix
soc_init_component_debugfs，初始化component的debugfs数据结构
snd_soc_dapm_new_controls，初始化挂在component上的widgets
snd_soc_dapm_new_dai_widgets，对每一个dapm dai，动态生成一个widgets，然后再probe这个dai的时候，动态生成一个从dai到device的dapm route，之后开关stream时，就可以调用soc_dapm_stream_event来控制相应的dapm事件
component->driver->probe(component)，依次调用rtd上的每一个component对应的probe函数
snd_soc_add_component_controls，初始化component上的所有kcontrol
snd_soc_dapm_add_routes，初始化dapm route对应的每一个path，如果path中对应的widgets是mux，mixer，switch时，会做特殊处理
dapm->card->paths

	switch (wsource->id) {
	case snd_soc_dapm_demux:
		ret = dapm_connect_mux(dapm, path, control, wsource);
		if (ret)
			goto err;
		break;
	default:
		break;
	}

	switch (wsink->id) {
	case snd_soc_dapm_mux:
		ret = dapm_connect_mux(dapm, path, control, wsink);
		if (ret != 0)
			goto err;
		break;
	case snd_soc_dapm_switch:
	case snd_soc_dapm_mixer:
	case snd_soc_dapm_mixer_named_ctl:

static int soc_probe_component(struct snd_soc_card *card,
	struct snd_soc_component *component)
{
	struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
	struct snd_soc_dai *dai;
	int ret;

	if (!strcmp(component->name, "snd-soc-dummy"))
		return 0;

	if (component->card) {
		if (component->card != card) {
			dev_err(component->dev,
				"Trying to bind component to card \"%s\" but is already bound to card \"%s\"\n",
				card->name, component->card->name);
			return -ENODEV;
		}
		return 0;
	}

	if (!try_module_get(component->dev->driver->owner))
		return -ENODEV;

	component->card = card;
	dapm->card = card;
	soc_set_name_prefix(card, component);

	soc_init_component_debugfs(component);

	if (component->driver->dapm_widgets) {
		ret = snd_soc_dapm_new_controls(dapm,
					component->driver->dapm_widgets,
					component->driver->num_dapm_widgets);

		if (ret != 0) {
			dev_err(component->dev,
				"Failed to create new controls %d\n", ret);
			goto err_probe;
		}
	}

	list_for_each_entry(dai, &component->dai_list, list) {
		ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
		if (ret != 0) {
			dev_err(component->dev,
				"Failed to create DAI widgets %d\n", ret);
			goto err_probe;
		}
	}

	if (component->driver->probe) {
		ret = component->driver->probe(component);
		if (ret < 0) {
			dev_err(component->dev,
				"ASoC: failed to probe component %d\n", ret);
			goto err_probe;
		}

		WARN(dapm->idle_bias_off &&
			dapm->bias_level != SND_SOC_BIAS_OFF,
			"codec %s can not start from non-off bias with idle_bias_off==1\n",
			component->name);
	}

	/* machine specific init */
	if (component->init) {
		ret = component->init(component);
		if (ret < 0) {
			dev_err(component->dev,
				"Failed to do machine specific init %d\n", ret);
			goto err_probe;
		}
	}

	if (component->driver->controls)
		snd_soc_add_component_controls(component,
					       component->driver->controls,
					       component->driver->num_controls);
	if (component->driver->dapm_routes)
		snd_soc_dapm_add_routes(dapm,
					component->driver->dapm_routes,
					component->driver->num_dapm_routes);

	list_add(&dapm->list, &card->dapm_list);
	list_add(&component->card_list, &card->component_dev_list);

	return 0;

err_probe:
	soc_cleanup_component_debugfs(component);
	component->card = NULL;
	module_put(component->dev->driver->owner);

	return ret;
}

soc_probe_aux_devices

probe auxiliary components

soc_probe_link_dais

soc_probe_dai，调用dai driver对应的probe
在soc_new_pcm中会判断dai_link是否为dynamic并选择相应的ops

	/* ASoC PCM operations */
	if (rtd->dai_link->dynamic) {
		rtd->ops.open		= dpcm_fe_dai_open;
		rtd->ops.hw_params	= dpcm_fe_dai_hw_params;
		rtd->ops.prepare	= dpcm_fe_dai_prepare;
		rtd->ops.trigger	= dpcm_fe_dai_trigger;
		rtd->ops.hw_free	= dpcm_fe_dai_hw_free;
		rtd->ops.close		= dpcm_fe_dai_close;
		rtd->ops.pointer	= soc_pcm_pointer;
		rtd->ops.delay_blk	= soc_pcm_delay_blk;
		rtd->ops.ioctl		= soc_pcm_ioctl;
		rtd->ops.compat_ioctl   = soc_pcm_compat_ioctl;
	} else {
		rtd->ops.open		= soc_pcm_open;
		rtd->ops.hw_params	= soc_pcm_hw_params;
		rtd->ops.prepare	= soc_pcm_prepare;
		rtd->ops.trigger	= soc_pcm_trigger;
		rtd->ops.hw_free	= soc_pcm_hw_free;
		rtd->ops.close		= soc_pcm_close;
		rtd->ops.pointer	= soc_pcm_pointer;
		rtd->ops.delay_blk	= soc_pcm_delay_blk;
		rtd->ops.ioctl		= soc_pcm_ioctl;
		rtd->ops.compat_ioctl   = soc_pcm_compat_ioctl;
	}

static int soc_probe_link_dais(struct snd_soc_card *card,
		struct snd_soc_pcm_runtime *rtd, int order)
{
	struct snd_soc_dai_link *dai_link = rtd->dai_link;
	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
	struct snd_soc_rtdcom_list *rtdcom;
	struct snd_soc_component *component;
	int i, ret, num;

	dev_dbg(card->dev, "ASoC: probe %s dai link %d late %d\n",
			card->name, rtd->num, order);

	/* set default power off timeout */
	rtd->pmdown_time = pmdown_time;

	ret = soc_probe_dai(cpu_dai, order);
	if (ret)
		return ret;

	/* probe the CODEC DAI */
	for (i = 0; i < rtd->num_codecs; i++) {
		ret = soc_probe_dai(rtd->codec_dais[i], order);
		if (ret)
			return ret;
	}

	/* complete DAI probe during last probe */
	if (order != SND_SOC_COMP_ORDER_LAST)
		return 0;

	/* do machine specific initialization */
	if (dai_link->init) {
		ret = dai_link->init(rtd);
		if (ret < 0) {
			dev_err(card->dev, "ASoC: failed to init %s: %d\n",
				dai_link->name, ret);
			return ret;
		}
	}

	if (dai_link->dai_fmt)
		snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);

	ret = soc_post_component_init(rtd, dai_link->name);
	if (ret)
		return ret;

#ifdef CONFIG_DEBUG_FS
	/* add DPCM sysfs entries */
	if (dai_link->dynamic)
		soc_dpcm_debugfs_add(rtd);
#endif

	num = rtd->num;

	/*
	 * most drivers will register their PCMs using DAI link ordering but
	 * topology based drivers can use the DAI link id field to set PCM
	 * device number and then use rtd + a base offset of the BEs.
	 */
	for_each_rtdcom(rtd, rtdcom) {
		component = rtdcom->component;

		if (!component->driver->use_dai_pcm_id)
			continue;

		if (rtd->dai_link->no_pcm)
			num += component->driver->be_pcm_base;
		else
			num = rtd->dai_link->id;
	}

	if (cpu_dai->driver->compress_new) {
		/*create compress_device"*/
		ret = cpu_dai->driver->compress_new(rtd, num);
		if (ret < 0) {
			dev_err(card->dev, "ASoC: can't create compress %s\n",
					 dai_link->stream_name);
			return ret;
		}
	} else {

		if (!dai_link->params) {
			/* create the pcm */
			ret = soc_new_pcm(rtd, num);
			if (ret < 0) {
				dev_err(card->dev, "ASoC: can't create pcm %s :%d\n",
				       dai_link->stream_name, ret);
				return ret;
			}
			ret = soc_link_dai_pcm_new(&cpu_dai, 1, rtd);
			if (ret < 0)
				return ret;
			ret = soc_link_dai_pcm_new(rtd->codec_dais,
						   rtd->num_codecs, rtd);
			if (ret < 0)
				return ret;
		} else {
			INIT_DELAYED_WORK(&rtd->delayed_work,
						codec2codec_close_delayed_work);

			/* link the DAI widgets */
			ret = soc_link_dai_widgets(card, dai_link, rtd);
			if (ret)
				return ret;
		}
	}

	return 0;
}

snd_soc_dapm_link_dai_widgets

将之前调用snd_soc_dapm_new_dai_widgets生成的dai widget与stream domain中声明的SND_SOC_DAPM_AIF_IN连接

snd_soc_dapm_connect_dai_link_widgets

之前动态创建了cpu dai的widget，codec dai的widget，现在在这两个widget中创建一个path

snd_soc_add_card_controls

实例化card->controls下的kcontrol

snd_soc_dapm_add_routes

card->dapm_routes
初始化dapm route对应的每一个path，如果path中对应的widgets是mux，mixer，switch时，会做特殊处理

snd_soc_dapm_new_widgets

any new dapm widgets and creates them if found

snd_card_register

至此，注册声卡

mnlife_
关注
专栏目录
Qualcomm（高通）平台开发系列讲解-音频设备操作流程
Poorest的博客
04-26 1265
本篇将介绍高通平台音频的操作基于高通平台，高通提供了libalsa-inf库来操作音频设备，下面介绍设置音频设备及操作步骤.
高通9008驱动，需要刷机的可以自取
02-27
“高通9008驱动”是针对高通芯片组设备的一种特定驱动程序，主要用于数据恢复、固件升级或刷机操作。高通作为全球知名的半导体和无线科技创新者，其芯片广泛应用于众多智能手机和平板电脑。9008端口是高通芯片的一个...
高通音频驱动录音流程（一)
qq_28217563的博客
03-01 2162
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案.
精通 Linux 设备驱动开发（三）
最新发布
龙哥盟
07-29 419
从架构的角度来看，ASoC 子系统的元素及其关系可以表示如下：图 5.1 – ASoC 架构上述图表总结了新的 ASoC 架构，其中机器实体包装了平台和编解码器实体。在内核 v4.18 之前的 ASoC 实现中，SoC 音频编解码器设备（现在由表示）和 SoC 平台接口（由表示）及其各自的数字音频接口之间有严格的分离。然而，编解码器、平台和其他组件之间的相似代码越来越多。这导致了一种新的通用方法，即的概念（可以指代编解码器或平台）和（指代它们各自的音频接口驱动程序）。
ALSA driver---register card
Fire的博客
04-19 1076
通过snd_soc_register_card来注册card，即注册整个machine driver. 此函数接收一个参数 snd_soc_card： /* SoC card */ struct snd_soc_card { const char *name; const char *long_name; const char *driver_name; ...
Linux内核4.14版本——alsa框架分析(6)-ASoC（Machine）
yangguoyu8023的博客
12-26 3206
alsa架构分析，ASoCf分析、Machine
声卡注册流程（linux-5.4）
雨天不打滑的博客
03-19 4569
介绍了linux-5.4的声卡注册流程
Linux ALSA驱动框架(一)--ALSA架构简介
qq_41750891的博客
06-01 1341
（１）ALSA简介(1)Native ALSA Application：tinyplay/tinycap/tinymix，这些用户程序直接调用 alsa 用户库接口来实现放音、录音、控制ALSA Library API：alsa 用户...
audio Asoc 驱动架构详解
qq_48709036的博客
04-20 2967
说明：文章可能有点乱，是平时分析记录的，但是比较详细。 Hardware Driver：音频硬件设备驱动，由三大部分组成，分别是 Machine、Platform、Codec。 ASoC音频驱动由三部分构成：platform，codec，machine。 machine 是包含 platform 与 codec 这两者之间通过i2s 连接控制， platform （cpu_dai） <----->codec_dai Platform：Platform驱动程序包括音频DM...
高通手机驱动 高通9008驱动万能版
04-05
这些驱动通常包括基带驱动、USB驱动、音频驱动、相机驱动等，确保手机的各个功能正常运行。安装正确的高通驱动是进行刷机、升级固件、故障排查等高级操作的基础。 二、高通9008驱动 高通9008模式，又称为9008端口...
Qualcomm高通9008驱动
10-20
Qualcomm高通9008驱动是针对使用高通骁龙处理器的设备提供的一种关键软件组件，主要用于设备的固件更新、刷机以及故障恢复等操作。在Android智能手机和平板电脑领域，9008模式通常被用作设备的下载模式，以便通过...
手机高通芯片驱动.rar
08-29
《高通芯片驱动详解及其在安卓手机刷机中的应用》 在智能手机领域，高通公司以其先进的芯片技术闻名，尤其在安卓系统中占据主导地位。本文将深入探讨高通芯片驱动的重要性和使用方法，以及如何解决高通芯片手机在...
Qualcomm Diagnostics高通Diag驱动
04-09
高通芯片的Diagnostics驱动，主要是在Win7下使用（因Win10自带了）。 配合QXDM使用。 小米5会被识别为Qualcomm HS-USB Diagnostics 90AD，红米5A会被识别为Qualcomm HS-USB Diagnostics 900E。 部分系统安装驱动后，...
alsa声卡驱动分析总结
wantianpei的专栏
10-14 2275
不小心 参考文章：http://blog.csdn.net/droidphone/            http://blog.chinaunix.net/uid/22917448.html 分析只列出部分重要代码，具体请参考linux3.0内核代码。 Alsa架构整体来说十分复杂，但对于驱动移植来说我们仅仅只需要关心ASOC就足够了。 在学习asoc之前我们先了解一些专业术语： A
嵌入式linux ASoC架构声卡驱动开发
qiaoyi的博客
10-19 1536
嵌入式linux ASoC架构声卡驱动开发 文章目录嵌入式linux ASoC架构声卡驱动开发需求分析ASoC架构下声卡驱动代码结构codec驱动snd_soc_register_codec分析平台驱动板驱动devm_snd_soc_register_card函数分析 需求分析 基于linux操作系统，使用ASoC框架，将系统中的音频文件从扬声器中播放出来。 首先，各种格式的音频文件，mp3,wav,FLAC,都是将模拟量以一定的规范进行了编码，才能保存下来的，所以对应的你需要一个播放器。播放器会将音频解
Linux 音频驱动(四) ASoC音频驱动之Machine驱动
_Modest_的博客
03-02 2524
目录1. 基本介绍2. 源码分析2.1. Machine数据结构 struct snd_soc_dai_link3. 声卡3.1. 数据结构struct snd_soc_card3.2. 注册声卡 snd_soc_register_card()3.3. soc_probe()函数 1. 基本介绍 Linux 音频驱动(二) ASoC音频驱动之Platform驱动和Linux 音频驱动(三) ASoC音频驱动之Codec驱动分别介绍了platform驱动、codec驱动，但仅有platform驱动、codec
alsa音频架构2-ASoc
paomadi的专栏
05-28 5970
设计ASoc的目的是为嵌入式系统片上处理器音频单元或外部的音频解码芯片提供更好的ALSA支持 ASoC有多个组件组成snd_soc_platform/snd_soc_codec/snd_soc_dai/snd_soc_card以及ALSA的snd_pcm snd_soc_platform和snd_soc_codec就行平台与设备的关系缺一不可,snd_soc_card是它们实例化的一个对象
devm_snd_soc_register_card
lihemian的专栏
11-22 184
* dai_link下的component和pcm绑定，就是确定了pcm下cpu dai对应的component和codec dai对应的component。/* 根据dai_link下的codec/cpu/platform去查找对应的component *//* 1. 统计"dai-link"子节点的个数num，也即最终会生成pcm设备的个数 *//* 5.1 遍历声卡下的所有dai_link *//* 3. 解析声卡节点的各个属性，以及每个dai-link子节点的各类属性 */
ASOC machine部分工作
奶牛养殖场小马
08-28 1716
由前面可知，ASoC被分为Machine、Platform和Codec三大部分,其中的Machine驱动负责Platform和Codec之间的耦合以及部分和设备或板子特定的代码，Machine为CPU、Codec、输入输出设备提供了一个载体。单独的Platform和Codec驱动是不能工作的，它必须由Machine驱动把它们结合在一起才能完成整个设备的音频处理工作。ASoC的一切都从Machine驱动开始，包括声卡的注册，绑定Platform和Codec驱动等等。//主要工作就在这里！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值