自学教程：C++ tegra_asoc_utils_fini函数代码示例

static int tegra_wm8753_driver_remove(struct platform_device *pdev){	struct snd_soc_card *card = platform_get_drvdata(pdev);	struct tegra_wm8753 *machine = snd_soc_card_get_drvdata(card);	struct tegra_asoc_platform_data *pdata = machine->pdata;	snd_soc_unregister_card(card);#ifdef CONFIG_SWITCH	tegra_asoc_switch_unregister(&wired_switch_dev);#endif	tegra_asoc_utils_fini(&machine->util_data);	if (machine->gpio_requested & GPIO_EXT_MIC_EN)		gpio_free(pdata->gpio_ext_mic_en);	if (machine->gpio_requested & GPIO_INT_MIC_EN)		gpio_free(pdata->gpio_int_mic_en);	if (machine->gpio_requested & GPIO_HP_MUTE)		gpio_free(pdata->gpio_hp_mute);	if (machine->gpio_requested & GPIO_SPKR_EN)		gpio_free(pdata->gpio_spkr_en);	if (machine->audio_reg) {		regulator_disable(machine->audio_reg);		regulator_put(machine->audio_reg);	}	return 0;}

static int __devexit tegra_wm8903_driver_remove(struct platform_device *pdev){	struct snd_soc_card *card = platform_get_drvdata(pdev);	struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);	struct tegra_wm8903_platform_data *pdata = &machine->pdata;	if (machine->gpio_requested & GPIO_HP_DET)		snd_soc_jack_free_gpios(&tegra_wm8903_hp_jack,					1,					&tegra_wm8903_hp_jack_gpio);	if (machine->gpio_requested & GPIO_EXT_MIC_EN)		gpio_free(pdata->gpio_ext_mic_en);	if (machine->gpio_requested & GPIO_INT_MIC_EN)		gpio_free(pdata->gpio_int_mic_en);	if (machine->gpio_requested & GPIO_HP_MUTE)		gpio_free(pdata->gpio_hp_mute);	if (machine->gpio_requested & GPIO_SPKR_EN)		gpio_free(pdata->gpio_spkr_en);	machine->gpio_requested = 0;	snd_soc_unregister_card(card);	tegra_asoc_utils_fini(&machine->util_data);	if (!IS_ERR(machine->pcm_dev))		platform_device_unregister(machine->pcm_dev);	return 0;}

static int __devexit tegra_aic326x_driver_remove(struct platform_device *pdev){	struct snd_soc_card *card = platform_get_drvdata(pdev);	struct tegra_aic326x *machine = snd_soc_card_get_drvdata(card);	struct tegra_aic326x_platform_data *pdata = machine->pdata;	snd_soc_unregister_card(card);#ifdef CONFIG_SWITCH	switch_dev_unregister(&aic326x_wired_switch_dev);#endif	tegra_asoc_utils_fini(&machine->util_data);	if (machine->gpio_requested & GPIO_EXT_MIC_EN)		gpio_free(pdata->gpio_ext_mic_en);	if (machine->gpio_requested & GPIO_INT_MIC_EN)		gpio_free(pdata->gpio_int_mic_en);	if (machine->gpio_requested & GPIO_HP_MUTE)		gpio_free(pdata->gpio_hp_mute);	if (machine->gpio_requested & GPIO_SPKR_EN)		gpio_free(pdata->gpio_spkr_en);	kfree(machine);	return 0;}

static __devinit int tegra_wm8903_driver_probe(struct platform_device *pdev){	struct snd_soc_card *card = &snd_soc_tegra_wm8903;	struct tegra_wm8903 *machine;	struct tegra_wm8903_platform_data *pdata;	int ret;	pdata = pdev->dev.platform_data;	if (!pdata) {		dev_err(&pdev->dev, "No platform data supplied/n");		return -EINVAL;	}	machine = kzalloc(sizeof(struct tegra_wm8903), GFP_KERNEL);	if (!machine) {		dev_err(&pdev->dev, "Can't allocate tegra_wm8903 struct/n");		return -ENOMEM;	}	machine->pdata = pdata;	ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev);	if (ret)		goto err_free_machine;	card->dev = &pdev->dev;	platform_set_drvdata(pdev, card);	snd_soc_card_set_drvdata(card, machine);	if (machine_is_harmony() || machine_is_ventana()) {		card->dapm_routes = harmony_audio_map;		card->num_dapm_routes = ARRAY_SIZE(harmony_audio_map);	} else if (machine_is_seaboard()) {		card->dapm_routes = seaboard_audio_map;		card->num_dapm_routes = ARRAY_SIZE(seaboard_audio_map);	} else if (machine_is_kaen()) {		card->dapm_routes = kaen_audio_map;		card->num_dapm_routes = ARRAY_SIZE(kaen_audio_map);	} else {		card->dapm_routes = aebl_audio_map;		card->num_dapm_routes = ARRAY_SIZE(aebl_audio_map);	}	ret = snd_soc_register_card(card);	if (ret) {		dev_err(&pdev->dev, "snd_soc_register_card failed (%d)/n",			ret);		goto err_fini_utils;	}	return 0;err_fini_utils:	tegra_asoc_utils_fini(&machine->util_data);err_free_machine:	kfree(machine);	return ret;}

static __devinit int tegra_max98095_driver_probe(struct platform_device *pdev){	struct snd_soc_card *card = &snd_soc_tegra_max98095;	struct tegra_max98095 *machine;	struct tegra_asoc_platform_data *pdata;	int ret;	pdata = pdev->dev.platform_data;	if (!pdata) {		dev_err(&pdev->dev, "No platform data supplied/n");		return -EINVAL;	}	machine = kzalloc(sizeof(struct tegra_max98095), GFP_KERNEL);	if (!machine) {		dev_err(&pdev->dev, "Can't allocate tegra_max98095 struct/n");		return -ENOMEM;	}	machine->pdata = pdata;	ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev);	if (ret)		goto err_free_machine;	card->dev = &pdev->dev;	platform_set_drvdata(pdev, card);	snd_soc_card_set_drvdata(card, machine);#ifdef CONFIG_SWITCH	/* Add h2w switch class support */	ret = switch_dev_register(&wired_switch_dev);	if (ret < 0) {		dev_err(&pdev->dev, "not able to register switch device/n");		goto err_fini_utils;	}#endif	ret = snd_soc_register_card(card);	if (ret) {		dev_err(&pdev->dev, "snd_soc_register_card failed (%d)/n",			ret);		goto err_switch_unregister;	}	return 0;err_switch_unregister:#ifdef CONFIG_SWITCH	switch_dev_unregister(&wired_switch_dev);#endiferr_fini_utils:	tegra_asoc_utils_fini(&machine->util_data);err_free_machine:	kfree(machine);	return ret;}

static int tegra_snd_trimslice_probe(struct platform_device *pdev){	struct device_node *np = pdev->dev.of_node;	struct snd_soc_card *card = &snd_soc_trimslice;	struct tegra_trimslice *trimslice;	int ret;	trimslice = devm_kzalloc(&pdev->dev, sizeof(struct tegra_trimslice),				 GFP_KERNEL);	if (!trimslice) {		dev_err(&pdev->dev, "Can't allocate tegra_trimslice/n");		return -ENOMEM;	}	card->dev = &pdev->dev;	platform_set_drvdata(pdev, card);	snd_soc_card_set_drvdata(card, trimslice);	trimslice_tlv320aic23_dai.codec_of_node = of_parse_phandle(np,			"nvidia,audio-codec", 0);	if (!trimslice_tlv320aic23_dai.codec_of_node) {		dev_err(&pdev->dev,			"Property 'nvidia,audio-codec' missing or invalid/n");		ret = -EINVAL;		goto err;	}	trimslice_tlv320aic23_dai.cpu_of_node = of_parse_phandle(np,			"nvidia,i2s-controller", 0);	if (!trimslice_tlv320aic23_dai.cpu_of_node) {		dev_err(&pdev->dev,			"Property 'nvidia,i2s-controller' missing or invalid/n");		ret = -EINVAL;		goto err;	}	trimslice_tlv320aic23_dai.platform_of_node =			trimslice_tlv320aic23_dai.cpu_of_node;	ret = tegra_asoc_utils_init(&trimslice->util_data, &pdev->dev);	if (ret)		goto err;	ret = snd_soc_register_card(card);	if (ret) {		dev_err(&pdev->dev, "snd_soc_register_card failed (%d)/n",			ret);		goto err_fini_utils;	}	return 0;err_fini_utils:	tegra_asoc_utils_fini(&trimslice->util_data);err:	return ret;}

static int tegra_wm8903_driver_remove(struct platform_device *pdev){	struct snd_soc_card *card = platform_get_drvdata(pdev);	struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);	snd_soc_unregister_card(card);	tegra_asoc_utils_fini(&machine->util_data);	return 0;}

static int tegra_snd_trimslice_remove(struct platform_device *pdev){	struct snd_soc_card *card = platform_get_drvdata(pdev);	struct tegra_trimslice *trimslice = snd_soc_card_get_drvdata(card);	snd_soc_unregister_card(card);	tegra_asoc_utils_fini(&trimslice->util_data);	return 0;}

static __devinit int tegra_aic3008_driver_probe(struct platform_device *pdev){	struct snd_soc_card *card = &snd_soc_tegra_aic3008;	struct tegra_aic3008 *machine;	struct htc_asoc_platform_data *pdata;	int ret;	AUD_INFO("starting tegra_aic3008_driver_probe.../n");	pdata = pdev->dev.platform_data;	if (!pdata) {		dev_err(&pdev->dev, "No platform data supplied/n");		return -EINVAL;	}	AUD_INFO("starting tegra_aic3008_driver_probe...%p %p/n", &pdata->aic3008_power, &aic3008_power_ctl);	aic3008_power_ctl = &pdata->aic3008_power;	machine = kzalloc(sizeof(struct tegra_aic3008), GFP_KERNEL);	if (!machine) {		AUD_ERR("Can't allocate tegra_aic3008 struct/n");		return -ENOMEM;	}	machine->pdata = pdata;	ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev, card);	util_data = &machine->util_data;	if (ret)		goto err_free_machine;	AUD_DBG("DONE tegra_asoc_utils_init()/n");	card->dev = &pdev->dev;	platform_set_drvdata(pdev, card);	snd_soc_card_set_drvdata(card, machine);	ret = snd_soc_register_card(card);	if (ret) {		AUD_ERR("snd_soc_register_card failed %d/n",ret);		goto err_unregister_switch;	}	AUD_DBG("DONE snd_soc_register_card()/n");	return 0;err_unregister_switch:	tegra_asoc_utils_fini(&machine->util_data);err_free_machine:	kfree(machine);	return ret;}

static int tegra20_ac97_platform_remove(struct platform_device *pdev){	struct tegra20_ac97 *ac97 = dev_get_drvdata(&pdev->dev);	tegra_pcm_platform_unregister(&pdev->dev);	snd_soc_unregister_dai(&pdev->dev);	tegra_asoc_utils_fini(&ac97->util_data);	clk_disable_unprepare(ac97->clk_ac97);	clk_put(ac97->clk_ac97);	return 0;}

static int tegra_dummy_machine_driver_probe(struct platform_device *pdev){	struct snd_soc_card *card = &snd_soc_tegra_dummy_machine;	struct tegra_dummy_machine *machine;	int ret;	machine = kzalloc(sizeof(struct tegra_dummy_machine), GFP_KERNEL);	if (!machine) {		dev_err(&pdev->dev, "Can't allocate tegra_dummy_machine struct/n");		return -ENOMEM;	}	machine->pcard = card;	ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev, card);	if (ret)		goto err_free_machine;	card->dev = &pdev->dev;	platform_set_drvdata(pdev, card);	snd_soc_card_set_drvdata(card, machine);	ret = snd_soc_register_card(card);	if (ret) {		dev_err(&pdev->dev, "snd_soc_register_card failed (%d)/n",			ret);		goto err_unregister_switch;	}	if (!card->instantiated) {		ret = -ENODEV;		dev_err(&pdev->dev, "sound card not instantiated (%d)/n",			ret);		goto err_unregister_card;	}	return 0;err_unregister_card:	snd_soc_unregister_card(card);err_unregister_switch:	tegra_asoc_utils_fini(&machine->util_data);err_free_machine:	kfree(machine);	return ret;}

static int __devexit tegra_alc5632_remove(struct platform_device *pdev){	struct snd_soc_card *card = platform_get_drvdata(pdev);	struct tegra_alc5632 *machine = snd_soc_card_get_drvdata(card);	if (machine->gpio_requested & GPIO_HP_DET)		snd_soc_jack_free_gpios(&tegra_alc5632_hs_jack,					1,					&tegra_alc5632_hp_jack_gpio);	machine->gpio_requested = 0;	snd_soc_unregister_card(card);	tegra_asoc_utils_fini(&machine->util_data);	return 0;}

static int tegra_wm8903_driver_remove(struct platform_device *pdev){	struct snd_soc_card *card = platform_get_drvdata(pdev);	struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);	snd_soc_jack_free_gpios(&tegra_wm8903_hp_jack, 1,				&tegra_wm8903_hp_jack_gpio);	if (machine->spk_reg)		regulator_put(machine->spk_reg);	if (machine->dmic_reg)		regulator_put(machine->dmic_reg);	snd_soc_unregister_card(card);	tegra_asoc_utils_fini(&machine->util_data);#ifdef CONFIG_SWITCH	tegra_asoc_switch_unregister(&tegra_wm8903_headset_switch);#endif	return 0;}

static __devinit int tegra_snd_trimslice_probe(struct platform_device *pdev){	struct snd_soc_card *card = &snd_soc_trimslice;	struct tegra_trimslice *trimslice;	int ret;	trimslice = devm_kzalloc(&pdev->dev, sizeof(struct tegra_trimslice),				 GFP_KERNEL);	if (!trimslice) {		dev_err(&pdev->dev, "Can't allocate tegra_trimslice/n");		ret = -ENOMEM;		goto err;	}	ret = tegra_asoc_utils_init(&trimslice->util_data, &pdev->dev);	if (ret)		goto err;	card->dev = &pdev->dev;	platform_set_drvdata(pdev, card);	snd_soc_card_set_drvdata(card, trimslice);	ret = snd_soc_register_card(card);	if (ret) {		dev_err(&pdev->dev, "snd_soc_register_card failed (%d)/n",			ret);		goto err_fini_utils;	}	return 0;err_fini_utils:	tegra_asoc_utils_fini(&trimslice->util_data);err:	return ret;}

//.........这里部分代码省略.........					    GPIOF_OUT_INIT_LOW, "spkr_en");		if (ret) {			dev_err(card->dev, "cannot get spkr_en gpio/n");			return ret;		}	}	machine->gpio_hp_mute = of_get_named_gpio(np, "nvidia,hp-mute-gpios",						  0);	if (machine->gpio_hp_mute == -EPROBE_DEFER)		return -EPROBE_DEFER;	if (gpio_is_valid(machine->gpio_hp_mute)) {		ret = devm_gpio_request_one(&pdev->dev, machine->gpio_hp_mute,					    GPIOF_OUT_INIT_HIGH, "hp_mute");		if (ret) {			dev_err(card->dev, "cannot get hp_mute gpio/n");			return ret;		}	}	machine->gpio_hp_det = of_get_named_gpio(np, "nvidia,hp-det-gpios", 0);	if (machine->gpio_hp_det == -EPROBE_DEFER)		return -EPROBE_DEFER;	machine->gpio_int_mic_en = of_get_named_gpio(np,						"nvidia,int-mic-en-gpios", 0);	if (machine->gpio_int_mic_en == -EPROBE_DEFER)		return -EPROBE_DEFER;	if (gpio_is_valid(machine->gpio_int_mic_en)) {		/* Disable int mic; enable signal is active-high */		ret = devm_gpio_request_one(&pdev->dev,					    machine->gpio_int_mic_en,					    GPIOF_OUT_INIT_LOW, "int_mic_en");		if (ret) {			dev_err(card->dev, "cannot get int_mic_en gpio/n");			return ret;		}	}	machine->gpio_ext_mic_en = of_get_named_gpio(np,						"nvidia,ext-mic-en-gpios", 0);	if (machine->gpio_ext_mic_en == -EPROBE_DEFER)		return -EPROBE_DEFER;	if (gpio_is_valid(machine->gpio_ext_mic_en)) {		/* Enable ext mic; enable signal is active-low */		ret = devm_gpio_request_one(&pdev->dev,					    machine->gpio_ext_mic_en,					    GPIOF_OUT_INIT_LOW, "ext_mic_en");		if (ret) {			dev_err(card->dev, "cannot get ext_mic_en gpio/n");			return ret;		}	}	ret = snd_soc_of_parse_card_name(card, "nvidia,model");	if (ret)		goto err;	ret = snd_soc_of_parse_audio_routing(card, "nvidia,audio-routing");	if (ret)		goto err;	tegra_wm8903_dai.codec_of_node = of_parse_phandle(np,						"nvidia,audio-codec", 0);	if (!tegra_wm8903_dai.codec_of_node) {		dev_err(&pdev->dev,			"Property 'nvidia,audio-codec' missing or invalid/n");		ret = -EINVAL;		goto err;	}	tegra_wm8903_dai.cpu_of_node = of_parse_phandle(np,			"nvidia,i2s-controller", 0);	if (!tegra_wm8903_dai.cpu_of_node) {		dev_err(&pdev->dev,			"Property 'nvidia,i2s-controller' missing or invalid/n");		ret = -EINVAL;		goto err;	}	tegra_wm8903_dai.platform_of_node = tegra_wm8903_dai.cpu_of_node;	ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev);	if (ret)		goto err;	ret = snd_soc_register_card(card);	if (ret) {		dev_err(&pdev->dev, "snd_soc_register_card failed (%d)/n",			ret);		goto err_fini_utils;	}	return 0;err_fini_utils:	tegra_asoc_utils_fini(&machine->util_data);err:	return ret;}

static int tegra_sgtl5000_driver_probe(struct platform_device *pdev){	struct device_node *np = pdev->dev.of_node;	struct snd_soc_card *card = &snd_soc_tegra_sgtl5000;	struct tegra_sgtl5000 *machine;	int ret;	machine = devm_kzalloc(&pdev->dev, sizeof(struct tegra_sgtl5000),			       GFP_KERNEL);	if (!machine)		return -ENOMEM;	card->dev = &pdev->dev;	snd_soc_card_set_drvdata(card, machine);	ret = snd_soc_of_parse_card_name(card, "nvidia,model");	if (ret)		goto err;	ret = snd_soc_of_parse_audio_routing(card, "nvidia,audio-routing");	if (ret)		goto err;	tegra_sgtl5000_dai.codec_of_node = of_parse_phandle(np,			"nvidia,audio-codec", 0);	if (!tegra_sgtl5000_dai.codec_of_node) {		dev_err(&pdev->dev,			"Property 'nvidia,audio-codec' missing or invalid/n");		ret = -EINVAL;		goto err;	}	tegra_sgtl5000_dai.cpu_of_node = of_parse_phandle(np,			"nvidia,i2s-controller", 0);	if (!tegra_sgtl5000_dai.cpu_of_node) {		dev_err(&pdev->dev,			"Property 'nvidia,i2s-controller' missing/invalid/n");		ret = -EINVAL;		goto err;	}	tegra_sgtl5000_dai.platform_of_node = tegra_sgtl5000_dai.cpu_of_node;	ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev);	if (ret)		goto err;	ret = snd_soc_register_card(card);	if (ret) {		dev_err(&pdev->dev, "snd_soc_register_card failed (%d)/n",			ret);		goto err_fini_utils;	}	return 0;err_fini_utils:	tegra_asoc_utils_fini(&machine->util_data);err:	return ret;}

static int tegra_alc5632_probe(struct platform_device *pdev){	struct device_node *np = pdev->dev.of_node;	struct snd_soc_card *card = &snd_soc_tegra_alc5632;	struct tegra_alc5632 *alc5632;	int ret;	alc5632 = devm_kzalloc(&pdev->dev,			sizeof(struct tegra_alc5632), GFP_KERNEL);	if (!alc5632) {		dev_err(&pdev->dev, "Can't allocate tegra_alc5632/n");		return -ENOMEM;	}	card->dev = &pdev->dev;	platform_set_drvdata(pdev, card);	snd_soc_card_set_drvdata(card, alc5632);	alc5632->gpio_hp_det = of_get_named_gpio(np, "nvidia,hp-det-gpios", 0);	if (alc5632->gpio_hp_det == -EPROBE_DEFER)		return -EPROBE_DEFER;	ret = snd_soc_of_parse_card_name(card, "nvidia,model");	if (ret)		goto err;	ret = snd_soc_of_parse_audio_routing(card, "nvidia,audio-routing");	if (ret)		goto err;	tegra_alc5632_dai.codec_of_node = of_parse_phandle(			pdev->dev.of_node, "nvidia,audio-codec", 0);	if (!tegra_alc5632_dai.codec_of_node) {		dev_err(&pdev->dev,			"Property 'nvidia,audio-codec' missing or invalid/n");		ret = -EINVAL;		goto err;	}	tegra_alc5632_dai.cpu_of_node = of_parse_phandle(np,			"nvidia,i2s-controller", 0);	if (!tegra_alc5632_dai.cpu_of_node) {		dev_err(&pdev->dev,			"Property 'nvidia,i2s-controller' missing or invalid/n");		ret = -EINVAL;		goto err;	}	tegra_alc5632_dai.platform_of_node = tegra_alc5632_dai.cpu_of_node;	ret = tegra_asoc_utils_init(&alc5632->util_data, &pdev->dev);	if (ret)		goto err;	ret = snd_soc_register_card(card);	if (ret) {		dev_err(&pdev->dev, "snd_soc_register_card failed (%d)/n",			ret);		goto err_fini_utils;	}	return 0;err_fini_utils:	tegra_asoc_utils_fini(&alc5632->util_data);err:	return ret;}

static __devinit int tegra_max98088_driver_probe(struct platform_device *pdev){	struct snd_soc_card *card = &snd_soc_tegra_max98088;	struct tegra_max98088 *machine;	struct tegra_max98088_platform_data *pdata;	int ret, i;	pdata = pdev->dev.platform_data;	if (!pdata) {		dev_err(&pdev->dev, "No platform data supplied/n");		return -EINVAL;	}	machine = kzalloc(sizeof(struct tegra_max98088), GFP_KERNEL);	if (!machine) {		dev_err(&pdev->dev, "Can't allocate tegra_max98088 struct/n");		return -ENOMEM;	}	machine->pdata = pdata;	ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev);	if (ret)		goto err_free_machine;	card->dev = &pdev->dev;	platform_set_drvdata(pdev, card);	snd_soc_card_set_drvdata(card, machine);#ifdef CONFIG_SWITCH	/* Add h2w switch class support */	ret = switch_dev_register(&wired_switch_dev);	if (ret < 0) {		dev_err(&pdev->dev, "not able to register switch device/n");		goto err_fini_utils;	}#endif#ifndef CONFIG_ARCH_TEGRA_2x_SOC	for (i = 0; i < NUM_I2S_DEVICES ; i++)		machine->codec_info[i].i2s_id = pdata->audio_port_id[i];	machine->codec_info[BASEBAND].rate = pdata->baseband_param.rate;	machine->codec_info[BASEBAND].channels = pdata->baseband_param.channels;	tegra_max98088_dai[DAI_LINK_HIFI].cpu_dai_name =	tegra_max98088_i2s_dai_name[machine->codec_info[HIFI_CODEC].i2s_id];	tegra_max98088_dai[DAI_LINK_BTSCO].cpu_dai_name =	tegra_max98088_i2s_dai_name[machine->codec_info[BT_SCO].i2s_id];#endif	ret = snd_soc_register_card(card);	if (ret) {		dev_err(&pdev->dev, "snd_soc_register_card failed (%d)/n",			ret);		goto err_switch_unregister;	}	return 0;err_switch_unregister:#ifdef CONFIG_SWITCH	switch_dev_unregister(&wired_switch_dev);#endiferr_fini_utils:	tegra_asoc_utils_fini(&machine->util_data);err_free_machine:	kfree(machine);	return ret;}

static int tegra_wm8753_driver_probe(struct platform_device *pdev){	struct snd_soc_card *card = &snd_soc_tegra_wm8753;	struct tegra_wm8753 *machine;	struct tegra_asoc_platform_data *pdata;	int ret;	pdata = pdev->dev.platform_data;	if (!pdata) {		dev_err(&pdev->dev, "No platform data supplied/n");		return -EINVAL;	}	machine = devm_kzalloc(&pdev->dev, sizeof(struct tegra_wm8753),			       GFP_KERNEL);	if (!machine) {		dev_err(&pdev->dev, "Can't allocate tegra_wm8753 struct/n");		ret = -ENOMEM;		goto err;	}	card->dev = &pdev->dev;	platform_set_drvdata(pdev, card);	snd_soc_card_set_drvdata(card, machine);	ret = snd_soc_of_parse_card_name(card, "nvidia,model");	if (ret)		goto err;	ret = snd_soc_of_parse_audio_routing(card, "nvidia,audio-routing");	if (ret)		goto err;	tegra_wm8753_dai.codec_of_node = of_parse_phandle(			pdev->dev.of_node, "nvidia,audio-codec", 0);	if (!tegra_wm8753_dai.codec_of_node) {		dev_err(&pdev->dev,			"Property 'nvidia,audio-codec' missing or invalid/n");		ret = -EINVAL;		goto err;	}	tegra_wm8753_dai.cpu_of_node = of_parse_phandle(			pdev->dev.of_node, "nvidia,i2s-controller", 0);	if (!tegra_wm8753_dai.cpu_of_node) {		dev_err(&pdev->dev,			"Property 'nvidia,i2s-controller' missing or invalid/n");		ret = -EINVAL;		goto err;	}	tegra_wm8753_dai.platform_of_node =				tegra_wm8753_dai.cpu_of_node;	ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev, card);	if (ret)		goto err;	ret = snd_soc_register_card(card);	if (ret) {		dev_err(&pdev->dev, "snd_soc_register_card failed (%d)/n",			ret);		goto err_fini_utils;	}	if (!card->instantiated) {		dev_err(&pdev->dev, "No WM8753 codec/n");		goto err_unregister_card;	}#ifdef CONFIG_SWITCH	/* Add h2w swith class support */	ret = tegra_asoc_switch_register(&wired_switch_dev);	if (ret < 0) {		dev_err(&pdev->dev, "not able to register switch device/n");		goto err_unregister_card;	}#endif#ifndef CONFIG_ARCH_TEGRA_2x_SOC	ret = tegra_asoc_utils_set_parent(&machine->util_data,				pdata->i2s_param[HIFI_CODEC].is_i2s_master);	if (ret) {		dev_err(&pdev->dev, "tegra_asoc_utils_set_parent failed (%d)/n",			ret);		goto err_unregister_card;	}#endif	return 0;err_unregister_card:	snd_soc_unregister_card(card);err_fini_utils:	tegra_asoc_utils_fini(&machine->util_data);err:	return ret;}