static __devinit int tegra_snd_tegra_alc5632_probe(struct platform_device *pdev)
{
struct snd_soc_card *card = &snd_soc_tegra_alc5632;
struct tegra_alc5632 *alc5632;
struct tegra_alc5632_audio_platform_data *pdata;
int ret;
if (!machine_is_paz00()) {
dev_err(&pdev->dev, "Not running on Toshiba AC100!\n");
return -ENODEV;
}
pdata = pdev->dev.platform_data;
if (!pdata) {
dev_err(&pdev->dev, "no platform data supplied\n");
return -EINVAL;
}
alc5632 = kzalloc(sizeof(struct tegra_alc5632), GFP_KERNEL);
if (!alc5632) {
dev_err(&pdev->dev, "Can't allocate tegra_alc5632\n");
return -ENOMEM;
}
alc5632->pdata = pdata;
ret = tegra_asoc_utils_init(&alc5632->util_data, &pdev->dev);
if (ret)
goto err_free_tegra_alc5632;
card->dev = &pdev->dev;
platform_set_drvdata(pdev, card);
snd_soc_card_set_drvdata(card, alc5632);
ret = snd_soc_register_card(card);
if (ret) {
dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
ret);
goto err_clear_drvdata;
}
return 0;
err_clear_drvdata:
snd_soc_card_set_drvdata(card, NULL);
platform_set_drvdata(pdev, NULL);
card->dev = NULL;
tegra_asoc_utils_fini(&alc5632->util_data);
err_free_tegra_alc5632:
kfree(alc5632);
return ret;
}
static int __devexit tegra_snd_seaboard_remove(struct platform_device *pdev)
{
struct snd_soc_card *card = platform_get_drvdata(pdev);
struct tegra_seaboard *seaboard = snd_soc_card_get_drvdata(card);
struct seaboard_audio_platform_data *pdata = seaboard->pdata;
snd_soc_unregister_card(card);
snd_soc_card_set_drvdata(card, NULL);
platform_set_drvdata(pdev, NULL);
card->dev = NULL;
regulator_put(seaboard->vdd_dmic);
tegra_asoc_utils_fini(&seaboard->util_data);
if (seaboard->gpio_requested & GPIO_HP_MUTE)
gpio_free(pdata->gpio_hp_mute);
if (seaboard->gpio_requested & GPIO_SPKR_EN)
gpio_free(pdata->gpio_spkr_en);
kfree(seaboard);
return 0;
}
static int __devexit tegra_snd_tegra_alc5632_remove(struct platform_device *pdev)
{
struct snd_soc_card *card = platform_get_drvdata(pdev);
struct tegra_alc5632 *alc5632 = snd_soc_card_get_drvdata(card);
if (alc5632->gpio_requested & GPIO_HP_DET)
snd_soc_jack_free_gpios(&tegra_alc5632_hp_jack, 1,
&tegra_alc5632_hp_jack_gpio);
snd_soc_unregister_card(card);
snd_soc_card_set_drvdata(card, NULL);
platform_set_drvdata(pdev, NULL);
card->dev = NULL;
tegra_asoc_utils_fini(&alc5632->util_data);
/* if (alc5632->gpio_requested & GPIO_EXT_MIC_EN)
gpio_free(pdata->gpio_ext_mic_en);
if (alc5632->gpio_requested & GPIO_INT_MIC_EN)
gpio_free(pdata->gpio_int_mic_en);
if (alc5632->gpio_requested & GPIO_SPKR_EN)
gpio_free(pdata->gpio_spkr_en);
*/
kfree(alc5632);
return 0;
}
static int __devinit snd_adonisuniv_probe(struct platform_device *pdev)
{
int ret;
struct wm5102_machine_priv *wm5102;
wm5102 = kzalloc(sizeof *wm5102, GFP_KERNEL);
if (!wm5102) {
pr_err("Failed to allocate memory\n");
return -ENOMEM;
}
exynos5_audio_set_mclk(1, 0);
ret = snd_soc_register_dais(&pdev->dev, adonisuniv_ext_dai,
ARRAY_SIZE(adonisuniv_ext_dai));
if (ret != 0)
pr_err("Failed to register external DAIs: %d\n", ret);
snd_soc_card_set_drvdata(&adonisuniv, wm5102);
adonisuniv.dev = &pdev->dev;
ret = snd_soc_register_card(&adonisuniv);
if (ret) {
dev_err(&pdev->dev, "snd_soc_register_card failed %d\n", ret);
kfree(wm5102);
}
adonisuniv_gpio_init();
return ret;
}
static int snd_cht_mc_probe(struct platform_device *pdev)
{
int ret_val = 0;
bool found = false;
struct cht_mc_private *drv;
drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_ATOMIC);
if (!drv)
return -ENOMEM;
if (ACPI_SUCCESS(acpi_get_devices(
"104C227E",
snd_acpi_codec_match,
&found, NULL)) && found) {
drv->ts3a227e_present = true;
} else {
/* no need probe TI jack detection chip */
snd_soc_card_cht.aux_dev = NULL;
snd_soc_card_cht.num_aux_devs = 0;
drv->ts3a227e_present = false;
}
/* register the soc card */
snd_soc_card_cht.dev = &pdev->dev;
snd_soc_card_set_drvdata(&snd_soc_card_cht, drv);
ret_val = devm_snd_soc_register_card(&pdev->dev, &snd_soc_card_cht);
if (ret_val) {
dev_err(&pdev->dev,
"snd_soc_register_card failed %d\n", ret_val);
return ret_val;
}
platform_set_drvdata(pdev, &snd_soc_card_cht);
return ret_val;
}
static int aml_m8_audio_probe(struct platform_device *pdev)
{
//struct device_node *np = pdev->dev.of_node;
struct snd_soc_card *card = &aml_snd_soc_card;
struct aml_audio_private_data *p_aml_audio;
int ret = 0;
printk(KERN_DEBUG "enter %s\n", __func__);
#ifdef CONFIG_USE_OF
p_aml_audio = devm_kzalloc(&pdev->dev,
sizeof(struct aml_audio_private_data), GFP_KERNEL);
if (!p_aml_audio) {
dev_err(&pdev->dev, "Can't allocate aml_audio_private_data\n");
ret = -ENOMEM;
goto err;
}
card->dev = &pdev->dev;
platform_set_drvdata(pdev, card);
snd_soc_card_set_drvdata(card, p_aml_audio);
if (!(pdev->dev.of_node)) {
dev_err(&pdev->dev, "Must be instantiated using device tree\n");
ret = -EINVAL;
goto err;
}
ret = snd_soc_of_parse_card_name(card, "aml,sound_card");
if (ret)
goto err;
ret = of_property_read_string_index(pdev->dev.of_node, "aml,codec_dai",
0, &aml_codec_dai_link[0].codec_dai_name);
if (ret)
goto err;
ret = snd_soc_of_parse_audio_routing(card, "aml,audio-routing");
if (ret)
goto err;
// aml_codec_dai_link[0].codec_of_node = of_parse_phandle(
// pdev->dev.of_node, "aml,audio-codec", 0);
ret = snd_soc_register_card(card);
if (ret) {
dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
ret);
goto err;
}
aml_m8_pinmux_init(card);
return 0;
#endif
err:
kfree(p_aml_audio);
return ret;
}
static __devinit int omap_abe_probe(struct platform_device *pdev)
{
struct omap_abe_twl6040_data *pdata = dev_get_platdata(&pdev->dev);
struct snd_soc_card *card = &omap_abe_card;
struct omap_abe_data *card_data;
int ret;
card->dev = &pdev->dev;
if (!pdata) {
dev_err(&pdev->dev, "Missing pdata\n");
return -ENODEV;
}
if (pdata->card_name) {
card->name = pdata->card_name;
} else {
dev_err(&pdev->dev, "Card name is not provided\n");
return -ENODEV;
}
if (!pdata->mclk_freq) {
dev_err(&pdev->dev, "MCLK frequency missing\n");
return -ENODEV;
}
if (pdata->has_abe) {
if (pdata->has_dmic) {
card->dai_link = omap_abe_dai_link;
card->num_links = ARRAY_SIZE(omap_abe_dai_link);
} else {
card->dai_link = omap_abe_no_dmic_dai;
card->num_links = ARRAY_SIZE(omap_abe_no_dmic_dai);
}
} else if (pdata->has_dmic) {
card->dai_link = twl6040_dmic_dai;
card->num_links = ARRAY_SIZE(twl6040_dmic_dai);
} else {
card->dai_link = twl6040_only_dai;
card->num_links = ARRAY_SIZE(twl6040_only_dai);
}
card_data = devm_kzalloc(&pdev->dev, sizeof(*card_data), GFP_KERNEL);
if (card_data == NULL)
return -ENOMEM;
snd_soc_card_set_drvdata(card, card_data);
ret = snd_soc_register_card(card);
if (ret)
dev_err(&pdev->dev, "snd_soc_register_card() failed: %d\n", ret);
card_data->av_switch_reg = regulator_get(&pdev->dev, "av-switch");
if (IS_ERR(card_data->av_switch_reg)) {
dev_warn(&pdev->dev, "couldn't get AV Switch regulator\n");
card_data->av_switch_reg = NULL;
}
return ret;
}
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);
#endif
err_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 __devinit int tegra_rt5640_driver_probe(struct platform_device *pdev)
{
struct snd_soc_card *card = &snd_soc_tegra_rt5640;
struct tegra_rt5640 *machine;
struct tegra_rt5640_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_rt5640), GFP_KERNEL);
if (!machine) {
dev_err(&pdev->dev, "Can't allocate tegra_rt5640 struct\n");
return -ENOMEM;
}
machine->pdata = pdata;
ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev, card);
if (ret)
goto err_free_machine;
/* Addd h2w swith class support */
card->dev = &pdev->dev;
platform_set_drvdata(pdev, card);
snd_soc_card_set_drvdata(card, machine);
card->dapm.idle_bias_off = 1;
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) {
ret = -ENODEV;
dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
ret);
goto err_unregister_card;
}
return 0;
err_unregister_card:
snd_soc_unregister_card(card);
err_fini_utils:
tegra_asoc_utils_fini(&machine->util_data);
err_free_machine:
kfree(machine);
return ret;
}
static __devinit int tegra_rt5631_driver_probe(struct platform_device *pdev)
{
struct snd_soc_card *card = &snd_soc_tegra_rt5631;
struct tegra_rt5631 *machine;
struct tegra_asoc_platform_data *pdata;
int ret;
printk("%s+\n", __func__);
pdata = pdev->dev.platform_data;
if (!pdata) {
dev_err(&pdev->dev, "No platform data supplied\n");
return -EINVAL;
}
machine = kzalloc(sizeof(struct tegra_rt5631), GFP_KERNEL);
if (!machine) {
dev_err(&pdev->dev, "Can't allocate tegra_rt5631 struct\n");
return -ENOMEM;
}
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_fini_utils;
}
#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
printk("%s-\n", __func__);
return 0;
err_unregister_card:
snd_soc_unregister_card(card);
err_fini_utils:
tegra_asoc_utils_fini(&machine->util_data);
err_free_machine:
kfree(machine);
return ret;
}
static int snd_cht_mc_probe(struct platform_device *pdev)
{
const struct dmi_system_id *dmi_id;
struct device *dev = &pdev->dev;
int ret_val = 0;
struct cht_mc_private *drv;
const char *mclk_name;
int quirks = 0;
dmi_id = dmi_first_match(cht_max98090_quirk_table);
if (dmi_id)
quirks = (unsigned long)dmi_id->driver_data;
drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL);
if (!drv)
return -ENOMEM;
drv->ts3a227e_present = acpi_dev_found("104C227E");
if (!drv->ts3a227e_present) {
/* no need probe TI jack detection chip */
snd_soc_card_cht.aux_dev = NULL;
snd_soc_card_cht.num_aux_devs = 0;
ret_val = devm_acpi_dev_add_driver_gpios(dev->parent,
acpi_max98090_gpios);
if (ret_val)
dev_dbg(dev, "Unable to add GPIO mapping table\n");
}
/* register the soc card */
snd_soc_card_cht.dev = &pdev->dev;
snd_soc_card_set_drvdata(&snd_soc_card_cht, drv);
if (quirks & QUIRK_PMC_PLT_CLK_0)
mclk_name = "pmc_plt_clk_0";
else
mclk_name = "pmc_plt_clk_3";
drv->mclk = devm_clk_get(&pdev->dev, mclk_name);
if (IS_ERR(drv->mclk)) {
dev_err(&pdev->dev,
"Failed to get MCLK from %s: %ld\n",
mclk_name, PTR_ERR(drv->mclk));
return PTR_ERR(drv->mclk);
}
ret_val = devm_snd_soc_register_card(&pdev->dev, &snd_soc_card_cht);
if (ret_val) {
dev_err(&pdev->dev,
"snd_soc_register_card failed %d\n", ret_val);
return ret_val;
}
platform_set_drvdata(pdev, &snd_soc_card_cht);
return ret_val;
}
/* SoC card */
static int snd_ctp_mc_probe(struct platform_device *pdev)
{
int ret_val = 0;
struct ctp_mc_private *ctx;
struct ctp_audio_platform_data *pdata = pdev->dev.platform_data;
pr_debug("In %s\n", __func__);
ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_ATOMIC);
if (!ctx) {
pr_err("allocation failed\n");
return -ENOMEM;
}
/* register the soc card */
snd_soc_card_ctp.dev = &pdev->dev;
ctx->ops = (struct snd_soc_machine_ops *)platform_get_device_id(pdev)->driver_data;
if (ctx->ops == NULL)
return -EINVAL;
ctx->ops->card_name(&snd_soc_card_ctp);
ctx->ops->dai_link(&snd_soc_card_ctp);
if (ctx->ops->dmic3_support) {
ret_val = gpio_request(pdata->codec_gpio_dmic, "dmic_switch_gpio");
if (!ret_val) {
ctx->dmic_gpio = pdata->codec_gpio_dmic;
} else {
pr_err("req dmic_switch_gpio failed:%d\n", ret_val);
return ret_val;
}
}
ret_val = snd_ctp_register_jack_data(pdev, ctx);
if (ret_val)
goto free_jack;
snd_soc_card_set_drvdata(&snd_soc_card_ctp, ctx);
ret_val = snd_soc_register_card(&snd_soc_card_ctp);
if (ret_val) {
pr_err("snd_soc_register_card failed %d\n", ret_val);
goto free_jack;
}
if (!snd_soc_card_ctp.instantiated) {
pr_err("snd_soc_card_ctp is not instantiated.\n");
ret_val = -ENODEV;
goto free_jack;
}
platform_set_drvdata(pdev, &snd_soc_card_ctp);
pr_debug("successfully exited probe\n");
return ret_val;
free_jack:
snd_ctp_unregister_jack(ctx, pdev);
return ret_val;
}
static int snd_ctp_mc_remove(struct platform_device *pdev)
{
struct snd_soc_card *soc_card = platform_get_drvdata(pdev);
struct ctp_mc_private *ctx = snd_soc_card_get_drvdata(soc_card);
pr_debug("In %s\n", __func__);
snd_ctp_unregister_jack(ctx, pdev);
snd_soc_card_set_drvdata(soc_card, NULL);
snd_soc_unregister_card(soc_card);
platform_set_drvdata(pdev, NULL);
return 0;
}
static int sirf_audio_probe(struct platform_device *pdev)
{
struct snd_soc_card *card = &snd_soc_sirf_audio_card;
struct sirf_audio_card *sirf_audio_card;
int ret;
sirf_audio_card = devm_kzalloc(&pdev->dev, sizeof(struct sirf_audio_card),
GFP_KERNEL);
if (sirf_audio_card == NULL)
return -ENOMEM;
sirf_audio_dai_link[0].cpu_of_node =
of_parse_phandle(pdev->dev.of_node, "sirf,audio-platform", 0);
sirf_audio_dai_link[0].platform_of_node =
of_parse_phandle(pdev->dev.of_node, "sirf,audio-platform", 0);
sirf_audio_dai_link[0].codec_of_node =
of_parse_phandle(pdev->dev.of_node, "sirf,audio-codec", 0);
sirf_audio_card->gpio_spk_pa = of_get_named_gpio(pdev->dev.of_node,
"spk-pa-gpios", 0);
sirf_audio_card->gpio_hp_pa = of_get_named_gpio(pdev->dev.of_node,
"hp-pa-gpios", 0);
if (gpio_is_valid(sirf_audio_card->gpio_spk_pa)) {
ret = devm_gpio_request_one(&pdev->dev,
sirf_audio_card->gpio_spk_pa,
GPIOF_OUT_INIT_LOW, "SPA_PA_SD");
if (ret) {
dev_err(&pdev->dev,
"Failed to request GPIO_%d for reset: %d\n",
sirf_audio_card->gpio_spk_pa, ret);
return ret;
}
}
if (gpio_is_valid(sirf_audio_card->gpio_hp_pa)) {
ret = devm_gpio_request_one(&pdev->dev,
sirf_audio_card->gpio_hp_pa,
GPIOF_OUT_INIT_LOW, "HP_PA_SD");
if (ret) {
dev_err(&pdev->dev,
"Failed to request GPIO_%d for reset: %d\n",
sirf_audio_card->gpio_hp_pa, ret);
return ret;
}
}
card->dev = &pdev->dev;
snd_soc_card_set_drvdata(card, sirf_audio_card);
ret = devm_snd_soc_register_card(&pdev->dev, card);
if (ret)
dev_err(&pdev->dev, "snd_soc_register_card() failed:%d\n", ret);
return ret;
}
static __devinit int omap_abe_probe(struct platform_device *pdev)
{
struct omap_abe_twl6040_data *pdata = dev_get_platdata(&pdev->dev);
struct snd_soc_card *card = &omap_abe_card;
struct abe_twl6040 *priv;
int num_links = 0;
int ret;
card->dev = &pdev->dev;
if (!pdata) {
dev_err(&pdev->dev, "Missing pdata\n");
return -ENODEV;
}
priv = devm_kzalloc(&pdev->dev, sizeof(struct abe_twl6040), GFP_KERNEL);
if (priv == NULL)
return -ENOMEM;
if (pdata->card_name) {
card->name = pdata->card_name;
} else {
dev_err(&pdev->dev, "Card name is not provided\n");
return -ENODEV;
}
priv->jack_detection = pdata->jack_detection;
priv->mclk_freq = pdata->mclk_freq;
if (!priv->mclk_freq) {
dev_err(&pdev->dev, "MCLK frequency missing\n");
return -ENODEV;
}
if (pdata->has_dmic)
num_links = 2;
else
num_links = 1;
card->dai_link = abe_twl6040_dai_links;
card->num_links = num_links;
snd_soc_card_set_drvdata(card, priv);
ret = snd_soc_register_card(card);
if (ret)
dev_err(&pdev->dev, "snd_soc_register_card() failed: %d\n",
ret);
return ret;
}
void mop500_ab8500_remove(struct snd_soc_card *card)
{
struct mop500_ab8500_drvdata *drvdata = snd_soc_card_get_drvdata(card);
if (drvdata->clk_ptr_sysclk != NULL)
clk_put(drvdata->clk_ptr_sysclk);
if (drvdata->clk_ptr_ulpclk != NULL)
clk_put(drvdata->clk_ptr_ulpclk);
if (drvdata->clk_ptr_intclk != NULL)
clk_put(drvdata->clk_ptr_intclk);
snd_soc_card_set_drvdata(card, drvdata);
}
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 sdm845_snd_platform_probe(struct platform_device *pdev)
{
struct snd_soc_card *card;
struct sdm845_snd_data *data;
struct device *dev = &pdev->dev;
int ret;
card = kzalloc(sizeof(*card), GFP_KERNEL);
if (!card)
return -ENOMEM;
/* Allocate the private data */
data = kzalloc(sizeof(*data), GFP_KERNEL);
if (!data) {
ret = -ENOMEM;
goto data_alloc_fail;
}
card->dapm_widgets = sdm845_snd_widgets;
card->num_dapm_widgets = ARRAY_SIZE(sdm845_snd_widgets);
card->dev = dev;
dev_set_drvdata(dev, card);
ret = qcom_snd_parse_of(card);
if (ret) {
dev_err(dev, "Error parsing OF data\n");
goto parse_dt_fail;
}
data->card = card;
snd_soc_card_set_drvdata(card, data);
sdm845_add_ops(card);
ret = snd_soc_register_card(card);
if (ret) {
dev_err(dev, "Sound card registration failed\n");
goto register_card_fail;
}
return ret;
register_card_fail:
kfree(card->dai_link);
parse_dt_fail:
kfree(data);
data_alloc_fail:
kfree(card);
return ret;
}
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 __devinit snd_manta_probe(struct platform_device *pdev)
{
struct manta_spdif *machine;
int ret;
machine = kzalloc(sizeof(*machine), GFP_KERNEL);
if (!machine) {
pr_err("%s: Failed to allocate memory\n", __func__);
ret = -ENOMEM;
goto err_kzalloc;
}
machine->clk_parent = clk_get(NULL, "fout_epll");
if (IS_ERR(machine->clk_parent)) {
pr_err("%s: failed to get fout_epll\n", __func__);
ret = PTR_ERR(machine->clk_parent);
goto err_clk_parent_get;
}
machine->clk_spdif = clk_get(NULL, "sclk_spdif");
if (IS_ERR(machine->clk_spdif)) {
pr_err("%s: failed to get sclk_spdif\n", __func__);
ret = PTR_ERR(machine->clk_spdif);
goto err_clk_spdif_get;
}
snd_soc_card_set_drvdata(&manta, machine);
manta.dev = &pdev->dev;
ret = snd_soc_register_card(&manta);
if (ret) {
dev_err(&pdev->dev, "snd_soc_register_card failed %d\n", ret);
goto err_register_card;
}
return 0;
err_register_card:
clk_put(machine->clk_spdif);
err_clk_spdif_get:
clk_put(machine->clk_parent);
err_clk_parent_get:
kfree(machine);
err_kzalloc:
return ret;
}
static int tau_dac_probe(struct platform_device *pdev)
{
int ret;
struct device_node *np;
struct snd_soc_card_drvdata *drvdata;
tau_dac_card.dev = &pdev->dev;
drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL);
if (drvdata == NULL)
return -ENOMEM;
np = pdev->dev.of_node;
if (np == NULL) {
dev_err(&pdev->dev, "Device tree node not found\n");
return -ENODEV;
}
/* set dai */
ret = tau_dac_set_dai(np);
if (ret != 0) {
dev_err(&pdev->dev, "Setting dai failed: %d\n", ret);
return ret;
}
/* set clocks */
ret = tau_dac_set_clk(&pdev->dev, drvdata);
if (ret != 0) {
if (ret != -EPROBE_DEFER)
dev_err(&pdev->dev, "Getting clocks failed: %d\n", ret);
return ret;
}
/* register card */
snd_soc_card_set_drvdata(&tau_dac_card, drvdata);
snd_soc_of_parse_card_name(&tau_dac_card, "tau-dac,model");
ret = snd_soc_register_card(&tau_dac_card);
if (ret != 0) {
if (ret != -EPROBE_DEFER)
dev_err(&pdev->dev, "snd_soc_register_card() failed: %d\n",
ret);
return ret;
}
return ret;
}
static int bdw_rt5677_probe(struct platform_device *pdev)
{
struct bdw_rt5677_priv *bdw_rt5677;
bdw_rt5677_card.dev = &pdev->dev;
/* Allocate driver private struct */
bdw_rt5677 = devm_kzalloc(&pdev->dev, sizeof(struct bdw_rt5677_priv),
GFP_KERNEL);
if (!bdw_rt5677) {
dev_err(&pdev->dev, "Can't allocate bdw_rt5677\n");
return -ENOMEM;
}
snd_soc_card_set_drvdata(&bdw_rt5677_card, bdw_rt5677);
return snd_soc_register_card(&bdw_rt5677_card);
}
static int davinci_evm_probe(struct platform_device *pdev)
{
struct device_node *np = pdev->dev.of_node;
const struct of_device_id *match =
of_match_device(of_match_ptr(davinci_evm_dt_ids), &pdev->dev);
struct snd_soc_dai_link *dai = (struct snd_soc_dai_link *) match->data;
struct snd_soc_card_drvdata_davinci *drvdata = NULL;
int ret = 0;
evm_soc_card.dai_link = dai;
dai->codec_of_node = of_parse_phandle(np, "ti,audio-codec", 0);
if (!dai->codec_of_node)
return -EINVAL;
dai->cpu_of_node = of_parse_phandle(np, "ti,mcasp-controller", 0);
if (!dai->cpu_of_node)
return -EINVAL;
dai->platform_of_node = dai->cpu_of_node;
evm_soc_card.dev = &pdev->dev;
ret = snd_soc_of_parse_card_name(&evm_soc_card, "ti,model");
if (ret)
return ret;
drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL);
if (!drvdata)
return -ENOMEM;
ret = of_property_read_u32(np, "ti,codec-clock-rate", &drvdata->sysclk);
if (ret < 0)
return -EINVAL;
snd_soc_card_set_drvdata(&evm_soc_card, drvdata);
ret = devm_snd_soc_register_card(&pdev->dev, &evm_soc_card);
if (ret)
dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n", ret);
return ret;
}
static int __init midas_audio_init(void)
{
struct wm1811_machine_priv *wm1811;
int ret;
wm1811 = kzalloc(sizeof *wm1811, GFP_KERNEL);
if (!wm1811) {
pr_err("Failed to allocate memory\n");
ret = -ENOMEM;
goto err_kzalloc;
}
snd_soc_card_set_drvdata(&midas, wm1811);
midas_snd_device = platform_device_alloc("soc-audio", -1);
if (!midas_snd_device) {
ret = -ENOMEM;
goto err_device_alloc;
}
ret = snd_soc_register_dais(&midas_snd_device->dev, midas_ext_dai,
ARRAY_SIZE(midas_ext_dai));
if (ret != 0)
pr_err("Failed to register external DAIs: %d\n", ret);
platform_set_drvdata(midas_snd_device, &midas);
ret = platform_device_add(midas_snd_device);
if (ret)
platform_device_put(midas_snd_device);
midas_gpio_init();
return ret;
err_device_alloc:
kfree(wm1811);
err_kzalloc:
return ret;
}
static __devinit int tegra_rt5631_driver_probe(struct platform_device *pdev)
{
struct snd_soc_card *card = &snd_soc_tegra_rt5631;
struct tegra_rt5631 *machine;
int ret;
printk("%s+\n", __func__);
machine = kzalloc(sizeof(struct tegra_rt5631), GFP_KERNEL);
if (!machine) {
dev_err(&pdev->dev, "Can't allocate tegra_rt5631 struct\n");
return -ENOMEM;
}
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_fini_utils;
}
printk("%s-\n", __func__);
return 0;
err_fini_utils:
tegra_asoc_utils_fini(&machine->util_data);
err_free_machine:
kfree(machine);
return ret;
}
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;
}
static int __devinit snd_adonisuniv_probe(struct platform_device *pdev)
{
int ret;
struct ymu831_machine_priv *ymu831;
ymu831 = kzalloc(sizeof(struct ymu831_machine_priv), GFP_KERNEL);
if (!ymu831) {
pr_err("Failed to allocate memory\n");
return -ENOMEM;
}
exynos5_audio_set_mclk(1, 0);
snd_soc_card_set_drvdata(&ymu831_snd_card, ymu831);
ymu831_snd_card.dev = &pdev->dev;
ret = snd_soc_register_card(&ymu831_snd_card);
if (ret) {
dev_err(&pdev->dev, "snd_soc_register_card failed %d\n", ret);
kfree(ymu831);
}
return ret;
}
static int mop500_probe(struct platform_device *pdev)
{
struct device_node *np = pdev->dev.of_node;
int ret;
dev_dbg(&pdev->dev, "%s: Enter.\n", __func__);
mop500_card.dev = &pdev->dev;
if (np) {
ret = mop500_of_probe(pdev, np);
if (ret)
return ret;
}
dev_dbg(&pdev->dev, "%s: Card %s: Set platform drvdata.\n",
__func__, mop500_card.name);
platform_set_drvdata(pdev, &mop500_card);
snd_soc_card_set_drvdata(&mop500_card, NULL);
dev_dbg(&pdev->dev, "%s: Card %s: num_links = %d\n",
__func__, mop500_card.name, mop500_card.num_links);
dev_dbg(&pdev->dev, "%s: Card %s: DAI-link 0: name = %s\n",
__func__, mop500_card.name, mop500_card.dai_link[0].name);
dev_dbg(&pdev->dev, "%s: Card %s: DAI-link 0: stream_name = %s\n",
__func__, mop500_card.name,
mop500_card.dai_link[0].stream_name);
ret = snd_soc_register_card(&mop500_card);
if (ret)
dev_err(&pdev->dev,
"Error: snd_soc_register_card failed (%d)!\n", ret);
return ret;
}
