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 spitz_probe(struct platform_device *pdev) { struct snd_soc_card *card = &snd_soc_spitz; int ret; if (machine_is_akita()) spitz_mic_gpio = AKITA_GPIO_MIC_BIAS; else spitz_mic_gpio = SPITZ_GPIO_MIC_BIAS; ret = gpio_request(spitz_mic_gpio, "MIC GPIO"); if (ret) goto err1; ret = gpio_direction_output(spitz_mic_gpio, 0); if (ret) goto err2; card->dev = &pdev->dev; ret = devm_snd_soc_register_card(&pdev->dev, card); if (ret) { dev_err(&pdev->dev, "snd_soc_register_card() failed: %d\n", ret); goto err2; } return 0; err2: gpio_free(spitz_mic_gpio); err1: return ret; }
static int byt_rt5640_probe(struct platform_device *pdev) { struct snd_soc_card *card = &byt_rt5640_card; card->dev = &pdev->dev; return devm_snd_soc_register_card(&pdev->dev, card); }
static int a370db_probe(struct platform_device *pdev) { struct snd_soc_card *card = &a370db; card->dev = &pdev->dev; a370db_dai[0].cpu_of_node = of_parse_phandle(pdev->dev.of_node, "marvell,audio-controller", 0); a370db_dai[0].platform_of_node = a370db_dai[0].cpu_of_node; a370db_dai[0].codec_of_node = of_parse_phandle(pdev->dev.of_node, "marvell,audio-codec", 0); a370db_dai[1].cpu_of_node = a370db_dai[0].cpu_of_node; a370db_dai[1].platform_of_node = a370db_dai[0].cpu_of_node; a370db_dai[1].codec_of_node = of_parse_phandle(pdev->dev.of_node, "marvell,audio-codec", 1); a370db_dai[2].cpu_of_node = a370db_dai[0].cpu_of_node; a370db_dai[2].platform_of_node = a370db_dai[0].cpu_of_node; a370db_dai[2].codec_of_node = of_parse_phandle(pdev->dev.of_node, "marvell,audio-codec", 2); return devm_snd_soc_register_card(card->dev, card); }
static int imx_spdif_audio_probe(struct platform_device *pdev) { struct device_node *spdif_np, *np = pdev->dev.of_node; struct imx_spdif_data *data; int ret = 0; spdif_np = of_parse_phandle(np, "spdif-controller", 0); if (!spdif_np) { dev_err(&pdev->dev, "failed to find spdif-controller\n"); ret = -EINVAL; goto end; } data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); if (!data) { ret = -ENOMEM; goto end; } data->dai.name = "S/PDIF PCM"; data->dai.stream_name = "S/PDIF PCM"; data->dai.codec_dai_name = "snd-soc-dummy-dai"; data->dai.codec_name = "snd-soc-dummy"; data->dai.cpu_of_node = spdif_np; data->dai.platform_of_node = spdif_np; data->dai.playback_only = true; data->dai.capture_only = true; if (of_property_read_bool(np, "spdif-out")) data->dai.capture_only = false; if (of_property_read_bool(np, "spdif-in")) data->dai.playback_only = false; if (data->dai.playback_only && data->dai.capture_only) { dev_err(&pdev->dev, "no enabled S/PDIF DAI link\n"); goto end; } data->card.dev = &pdev->dev; data->card.dai_link = &data->dai; data->card.num_links = 1; data->card.owner = THIS_MODULE; ret = snd_soc_of_parse_card_name(&data->card, "model"); if (ret) goto end; ret = devm_snd_soc_register_card(&pdev->dev, &data->card); if (ret) { dev_err(&pdev->dev, "snd_soc_register_card failed: %d\n", ret); goto end; } end: of_node_put(spdif_np); return ret; }
static int bfin_eval_adau1701_probe(struct platform_device *pdev) { struct snd_soc_card *card = &bfin_eval_adau1701; card->dev = &pdev->dev; return devm_snd_soc_register_card(&pdev->dev, &bfin_eval_adau1701); }
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; }
static int brownstone_probe(struct platform_device *pdev) { int ret; brownstone.dev = &pdev->dev; ret = devm_snd_soc_register_card(&pdev->dev, &brownstone); if (ret) dev_err(&pdev->dev, "snd_soc_register_card() failed: %d\n", ret); return ret; }
static int snd_smdk_probe(struct platform_device *pdev) { int ret = 0; smdk_pcm.dev = &pdev->dev; ret = devm_snd_soc_register_card(&pdev->dev, &smdk_pcm); if (ret) dev_err(&pdev->dev, "snd_soc_register_card failed %d\n", ret); return ret; }
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 int snd_rk_mc_probe(struct platform_device *pdev) { int ret = 0; struct snd_soc_card *card = &snd_soc_card_rk; struct device_node *np = pdev->dev.of_node; /* register the soc card */ card->dev = &pdev->dev; rk_dailink.codec_of_node = of_parse_phandle(np, "rockchip,audio-codec", 0); if (!rk_dailink.codec_of_node) { dev_err(&pdev->dev, "Property 'rockchip,audio-codec' missing or invalid\n"); return -EINVAL; } rk_dailink.cpu_of_node = of_parse_phandle(np, "rockchip,i2s-controller", 0); if (!rk_dailink.cpu_of_node) { dev_err(&pdev->dev, "Property 'rockchip,i2s-controller' missing or invalid\n"); return -EINVAL; } rk_dailink.platform_of_node = rk_dailink.cpu_of_node; rk_98090_headset_dev.codec_of_node = of_parse_phandle(np, "rockchip,headset-codec", 0); if (!rk_98090_headset_dev.codec_of_node) { dev_err(&pdev->dev, "Property 'rockchip,headset-codec' missing/invalid\n"); return -EINVAL; } ret = snd_soc_of_parse_card_name(card, "rockchip,model"); if (ret) { dev_err(&pdev->dev, "Soc parse card name failed %d\n", ret); return ret; } ret = devm_snd_soc_register_card(&pdev->dev, card); if (ret) { dev_err(&pdev->dev, "Soc register card failed %d\n", ret); return ret; } return ret; }
static int mxs_sgtl5000_probe(struct platform_device *pdev) { struct snd_soc_card *card = &mxs_sgtl5000; int ret, i; struct device_node *np = pdev->dev.of_node; struct device_node *saif_np[2], *codec_np; saif_np[0] = of_parse_phandle(np, "saif-controllers", 0); saif_np[1] = of_parse_phandle(np, "saif-controllers", 1); codec_np = of_parse_phandle(np, "audio-codec", 0); if (!saif_np[0] || !saif_np[1] || !codec_np) { dev_err(&pdev->dev, "phandle missing or invalid\n"); return -EINVAL; } for (i = 0; i < 2; i++) { mxs_sgtl5000_dai[i].codec_name = NULL; mxs_sgtl5000_dai[i].codec_of_node = codec_np; mxs_sgtl5000_dai[i].cpu_dai_name = NULL; mxs_sgtl5000_dai[i].cpu_of_node = saif_np[i]; mxs_sgtl5000_dai[i].platform_name = NULL; mxs_sgtl5000_dai[i].platform_of_node = saif_np[i]; } of_node_put(codec_np); of_node_put(saif_np[0]); of_node_put(saif_np[1]); /* * Set an init clock(11.28Mhz) for sgtl5000 initialization(i2c r/w). * The Sgtl5000 sysclk is derived from saif0 mclk and it's range * should be >= 8MHz and <= 27M. */ ret = mxs_saif_get_mclk(0, 44100 * 256, 44100); if (ret) { dev_err(&pdev->dev, "failed to get mclk\n"); return ret; } card->dev = &pdev->dev; platform_set_drvdata(pdev, 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; } return 0; }
static int lowland_probe(struct platform_device *pdev) { struct snd_soc_card *card = &lowland; int ret; card->dev = &pdev->dev; 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 int snd_byt_mc_probe(struct platform_device *pdev) { int ret_val = 0; /* register the soc card */ snd_soc_card_byt.dev = &pdev->dev; ret_val = devm_snd_soc_register_card(&pdev->dev, &snd_soc_card_byt); if (ret_val) { dev_err(&pdev->dev, "devm_snd_soc_register_card failed %d\n", ret_val); return ret_val; } platform_set_drvdata(pdev, &snd_soc_card_byt); return ret_val; }
static int mioa701_wm9713_probe(struct platform_device *pdev) { int rc; if (!machine_is_mioa701()) return -ENODEV; mioa701.dev = &pdev->dev; rc = devm_snd_soc_register_card(&pdev->dev, &mioa701); if (!rc) dev_warn(&pdev->dev, "Be warned that incorrect mixers/muxes setup will" "lead to overheating and possible destruction of your device." " Do not use without a good knowledge of mio's board design!\n"); return rc; }
static int cz_probe(struct platform_device *pdev) { int ret; struct snd_soc_card *card; card = &cz_card; cz_card.dev = &pdev->dev; platform_set_drvdata(pdev, card); ret = devm_snd_soc_register_card(&pdev->dev, &cz_card); if (ret) { dev_err(&pdev->dev, "devm_snd_soc_register_card(%s) failed: %d\n", cz_card.name, ret); return ret; } return 0; }
/* * After SMDKC110 Base Board's Rev is '0.1', 12MHz External OSC(X1) * is absent (or not connected), so we connect EXT_VOICE_CLK(OSC4), * 2.0484Mhz, directly with MCLK both Codec and SoC. */ static int snd_smdk_probe(struct platform_device *pdev) { int ret = 0; xtal_freq = SMDK_WM8580_EXT_OSC; mclk_freq = SMDK_WM8580_EXT_MCLK; if (machine_is_smdkc110() || machine_is_smdkv210()) xtal_freq = mclk_freq = SMDK_WM8580_EXT_VOICE; smdk_pcm.dev = &pdev->dev; ret = devm_snd_soc_register_card(&pdev->dev, &smdk_pcm); if (ret) dev_err(&pdev->dev, "snd_soc_register_card failed %d\n", ret); return ret; }
static int mt8173_rt5650_rt5514_dev_probe(struct platform_device *pdev) { struct snd_soc_card *card = &mt8173_rt5650_rt5514_card; struct device_node *platform_node; int i, ret; platform_node = of_parse_phandle(pdev->dev.of_node, "mediatek,platform", 0); if (!platform_node) { dev_err(&pdev->dev, "Property 'platform' missing or invalid\n"); return -EINVAL; } for (i = 0; i < card->num_links; i++) { if (mt8173_rt5650_rt5514_dais[i].platform_name) continue; mt8173_rt5650_rt5514_dais[i].platform_of_node = platform_node; } mt8173_rt5650_rt5514_codecs[0].of_node = of_parse_phandle(pdev->dev.of_node, "mediatek,audio-codec", 0); if (!mt8173_rt5650_rt5514_codecs[0].of_node) { dev_err(&pdev->dev, "Property 'audio-codec' missing or invalid\n"); return -EINVAL; } mt8173_rt5650_rt5514_codecs[1].of_node = of_parse_phandle(pdev->dev.of_node, "mediatek,audio-codec", 1); if (!mt8173_rt5650_rt5514_codecs[1].of_node) { dev_err(&pdev->dev, "Property 'audio-codec' missing or invalid\n"); return -EINVAL; } mt8173_rt5650_rt5514_codec_conf[0].of_node = mt8173_rt5650_rt5514_codecs[1].of_node; card->dev = &pdev->dev; platform_set_drvdata(pdev, card); ret = devm_snd_soc_register_card(&pdev->dev, card); if (ret) dev_err(&pdev->dev, "%s snd_soc_register_card fail %d\n", __func__, ret); return ret; }
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 tosa_probe(struct platform_device *pdev) { struct snd_soc_card *card = ⤩ int ret; ret = gpio_request_one(TOSA_GPIO_L_MUTE, GPIOF_OUT_INIT_LOW, "Headphone Jack"); if (ret) return ret; card->dev = &pdev->dev; ret = devm_snd_soc_register_card(&pdev->dev, card); if (ret) { dev_err(&pdev->dev, "snd_soc_register_card() failed: %d\n", ret); gpio_free(TOSA_GPIO_L_MUTE); } return ret; }
static int hx4700_audio_probe(struct platform_device *pdev) { int ret; if (!machine_is_h4700()) return -ENODEV; ret = gpio_request_array(hx4700_audio_gpios, ARRAY_SIZE(hx4700_audio_gpios)); if (ret) return ret; snd_soc_card_hx4700.dev = &pdev->dev; ret = devm_snd_soc_register_card(&pdev->dev, &snd_soc_card_hx4700); if (ret) gpio_free_array(hx4700_audio_gpios, ARRAY_SIZE(hx4700_audio_gpios)); return ret; }
static int e800_probe(struct platform_device *pdev) { struct snd_soc_card *card = &e800; int ret; ret = gpio_request_array(e800_audio_gpios, ARRAY_SIZE(e800_audio_gpios)); if (ret) return ret; card->dev = &pdev->dev; ret = devm_snd_soc_register_card(&pdev->dev, card); if (ret) { dev_err(&pdev->dev, "snd_soc_register_card() failed: %d\n", ret); gpio_free_array(e800_audio_gpios, ARRAY_SIZE(e800_audio_gpios)); } return ret; }
static int snow_probe(struct platform_device *pdev) { struct snd_soc_card *card = &snow_snd; struct device_node *i2s_node, *codec_node; int i, ret; i2s_node = of_parse_phandle(pdev->dev.of_node, "samsung,i2s-controller", 0); if (!i2s_node) { dev_err(&pdev->dev, "Property 'i2s-controller' missing or invalid\n"); return -EINVAL; } codec_node = of_parse_phandle(pdev->dev.of_node, "samsung,audio-codec", 0); if (!codec_node) { dev_err(&pdev->dev, "Property 'audio-codec' missing or invalid\n"); return -EINVAL; } for (i = 0; i < ARRAY_SIZE(snow_dai); i++) { snow_dai[i].codec_of_node = codec_node; snow_dai[i].cpu_of_node = i2s_node; snow_dai[i].platform_of_node = i2s_node; } card->dev = &pdev->dev; /* Update card-name if provided through DT, else use default name */ snd_soc_of_parse_card_name(card, "samsung,model"); 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; } return ret; }
static int arndale_audio_probe(struct platform_device *pdev) { int n, ret; struct device_node *np = pdev->dev.of_node; struct snd_soc_card *card = &arndale_rt5631; card->dev = &pdev->dev; for (n = 0; np && n < ARRAY_SIZE(arndale_rt5631_dai); n++) { if (!arndale_rt5631_dai[n].cpu_dai_name) { arndale_rt5631_dai[n].cpu_of_node = of_parse_phandle(np, "samsung,audio-cpu", n); if (!arndale_rt5631_dai[n].cpu_of_node) { dev_err(&pdev->dev, "Property 'samsung,audio-cpu' missing or invalid\n"); return -EINVAL; } } if (!arndale_rt5631_dai[n].platform_name) arndale_rt5631_dai[n].platform_of_node = arndale_rt5631_dai[n].cpu_of_node; arndale_rt5631_dai[n].codec_name = NULL; arndale_rt5631_dai[n].codec_of_node = of_parse_phandle(np, "samsung,audio-codec", n); if (!arndale_rt5631_dai[0].codec_of_node) { dev_err(&pdev->dev, "Property 'samsung,audio-codec' missing or invalid\n"); return -EINVAL; } } ret = devm_snd_soc_register_card(card->dev, card); if (ret) dev_err(&pdev->dev, "snd_soc_register_card() failed:%d\n", ret); return ret; }
static int mt8173_max98090_dev_probe(struct platform_device *pdev) { struct snd_soc_card *card = &mt8173_max98090_card; struct device_node *codec_node, *platform_node; int ret, i; platform_node = of_parse_phandle(pdev->dev.of_node, "mediatek,platform", 0); if (!platform_node) { dev_err(&pdev->dev, "Property 'platform' missing or invalid\n"); return -EINVAL; } for (i = 0; i < card->num_links; i++) { if (mt8173_max98090_dais[i].platform_name) continue; mt8173_max98090_dais[i].platform_of_node = platform_node; } codec_node = of_parse_phandle(pdev->dev.of_node, "mediatek,audio-codec", 0); if (!codec_node) { dev_err(&pdev->dev, "Property 'audio-codec' missing or invalid\n"); return -EINVAL; } for (i = 0; i < card->num_links; i++) { if (mt8173_max98090_dais[i].codec_name) continue; mt8173_max98090_dais[i].codec_of_node = codec_node; } card->dev = &pdev->dev; ret = devm_snd_soc_register_card(&pdev->dev, card); if (ret) dev_err(&pdev->dev, "%s snd_soc_register_card fail %d\n", __func__, ret); return ret; }
static int fsl_asoc_card_probe(struct platform_device *pdev) { struct device_node *cpu_np, *codec_np, *asrc_np; struct device_node *np = pdev->dev.of_node; struct platform_device *asrc_pdev = NULL; struct platform_device *cpu_pdev; struct fsl_asoc_card_priv *priv; struct i2c_client *codec_dev; const char *codec_dai_name; u32 width; int ret; priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; cpu_np = of_parse_phandle(np, "audio-cpu", 0); /* Give a chance to old DT binding */ if (!cpu_np) cpu_np = of_parse_phandle(np, "ssi-controller", 0); if (!cpu_np) { dev_err(&pdev->dev, "CPU phandle missing or invalid\n"); ret = -EINVAL; goto fail; } cpu_pdev = of_find_device_by_node(cpu_np); if (!cpu_pdev) { dev_err(&pdev->dev, "failed to find CPU DAI device\n"); ret = -EINVAL; goto fail; } codec_np = of_parse_phandle(np, "audio-codec", 0); if (codec_np) codec_dev = of_find_i2c_device_by_node(codec_np); else codec_dev = NULL; asrc_np = of_parse_phandle(np, "audio-asrc", 0); if (asrc_np) asrc_pdev = of_find_device_by_node(asrc_np); /* Get the MCLK rate only, and leave it controlled by CODEC drivers */ if (codec_dev) { struct clk *codec_clk = clk_get(&codec_dev->dev, NULL); if (!IS_ERR(codec_clk)) { priv->codec_priv.mclk_freq = clk_get_rate(codec_clk); clk_put(codec_clk); } } /* Default sample rate and format, will be updated in hw_params() */ priv->sample_rate = 44100; priv->sample_format = SNDRV_PCM_FORMAT_S16_LE; /* Assign a default DAI format, and allow each card to overwrite it */ priv->dai_fmt = DAI_FMT_BASE; /* Diversify the card configurations */ if (of_device_is_compatible(np, "fsl,imx-audio-cs42888")) { codec_dai_name = "cs42888"; priv->card.set_bias_level = NULL; priv->cpu_priv.sysclk_freq[TX] = priv->codec_priv.mclk_freq; priv->cpu_priv.sysclk_freq[RX] = priv->codec_priv.mclk_freq; priv->cpu_priv.sysclk_dir[TX] = SND_SOC_CLOCK_OUT; priv->cpu_priv.sysclk_dir[RX] = SND_SOC_CLOCK_OUT; priv->cpu_priv.slot_width = 32; priv->dai_fmt |= SND_SOC_DAIFMT_CBS_CFS; } else if (of_device_is_compatible(np, "fsl,imx-audio-cs427x")) { codec_dai_name = "cs4271-hifi"; priv->codec_priv.mclk_id = CS427x_SYSCLK_MCLK; priv->dai_fmt |= SND_SOC_DAIFMT_CBM_CFM; } else if (of_device_is_compatible(np, "fsl,imx-audio-sgtl5000")) { codec_dai_name = "sgtl5000"; priv->codec_priv.mclk_id = SGTL5000_SYSCLK; priv->dai_fmt |= SND_SOC_DAIFMT_CBM_CFM; } else if (of_device_is_compatible(np, "fsl,imx-audio-wm8962")) { codec_dai_name = "wm8962"; priv->card.set_bias_level = fsl_asoc_card_set_bias_level; priv->codec_priv.mclk_id = WM8962_SYSCLK_MCLK; priv->codec_priv.fll_id = WM8962_SYSCLK_FLL; priv->codec_priv.pll_id = WM8962_FLL; priv->dai_fmt |= SND_SOC_DAIFMT_CBM_CFM; } else if (of_device_is_compatible(np, "fsl,imx-audio-wm8960")) { codec_dai_name = "wm8960-hifi"; priv->card.set_bias_level = fsl_asoc_card_set_bias_level; priv->codec_priv.fll_id = WM8960_SYSCLK_AUTO; priv->codec_priv.pll_id = WM8960_SYSCLK_AUTO; priv->dai_fmt |= SND_SOC_DAIFMT_CBM_CFM; } else if (of_device_is_compatible(np, "fsl,imx-audio-ac97")) { codec_dai_name = "ac97-hifi"; priv->card.set_bias_level = NULL; priv->dai_fmt = SND_SOC_DAIFMT_AC97; } else { dev_err(&pdev->dev, "unknown Device Tree compatible\n"); ret = -EINVAL; goto asrc_fail; } if (!fsl_asoc_card_is_ac97(priv) && !codec_dev) { dev_err(&pdev->dev, "failed to find codec device\n"); ret = -EINVAL; goto asrc_fail; } /* Common settings for corresponding Freescale CPU DAI driver */ if (strstr(cpu_np->name, "ssi")) { /* Only SSI needs to configure AUDMUX */ ret = fsl_asoc_card_audmux_init(np, priv); if (ret) { dev_err(&pdev->dev, "failed to init audmux\n"); goto asrc_fail; } } else if (strstr(cpu_np->name, "esai")) { priv->cpu_priv.sysclk_id[1] = ESAI_HCKT_EXTAL; priv->cpu_priv.sysclk_id[0] = ESAI_HCKR_EXTAL; } else if (strstr(cpu_np->name, "sai")) { priv->cpu_priv.sysclk_id[1] = FSL_SAI_CLK_MAST1; priv->cpu_priv.sysclk_id[0] = FSL_SAI_CLK_MAST1; } snprintf(priv->name, sizeof(priv->name), "%s-audio", fsl_asoc_card_is_ac97(priv) ? "ac97" : codec_dev->name); /* Initialize sound card */ priv->pdev = pdev; priv->card.dev = &pdev->dev; priv->card.name = priv->name; priv->card.dai_link = priv->dai_link; priv->card.dapm_routes = fsl_asoc_card_is_ac97(priv) ? audio_map_ac97 : audio_map; priv->card.late_probe = fsl_asoc_card_late_probe; priv->card.num_dapm_routes = ARRAY_SIZE(audio_map); priv->card.dapm_widgets = fsl_asoc_card_dapm_widgets; priv->card.num_dapm_widgets = ARRAY_SIZE(fsl_asoc_card_dapm_widgets); /* Drop the second half of DAPM routes -- ASRC */ if (!asrc_pdev) priv->card.num_dapm_routes /= 2; memcpy(priv->dai_link, fsl_asoc_card_dai, sizeof(struct snd_soc_dai_link) * ARRAY_SIZE(priv->dai_link)); ret = snd_soc_of_parse_audio_routing(&priv->card, "audio-routing"); if (ret) { dev_err(&pdev->dev, "failed to parse audio-routing: %d\n", ret); goto asrc_fail; } /* Normal DAI Link */ priv->dai_link[0].cpu_of_node = cpu_np; priv->dai_link[0].codec_dai_name = codec_dai_name; if (!fsl_asoc_card_is_ac97(priv)) priv->dai_link[0].codec_of_node = codec_np; else { u32 idx; ret = of_property_read_u32(cpu_np, "cell-index", &idx); if (ret) { dev_err(&pdev->dev, "cannot get CPU index property\n"); goto asrc_fail; } priv->dai_link[0].codec_name = devm_kasprintf(&pdev->dev, GFP_KERNEL, "ac97-codec.%u", (unsigned int)idx); } priv->dai_link[0].platform_of_node = cpu_np; priv->dai_link[0].dai_fmt = priv->dai_fmt; priv->card.num_links = 1; if (asrc_pdev) { /* DPCM DAI Links only if ASRC exsits */ priv->dai_link[1].cpu_of_node = asrc_np; priv->dai_link[1].platform_of_node = asrc_np; priv->dai_link[2].codec_dai_name = codec_dai_name; priv->dai_link[2].codec_of_node = codec_np; priv->dai_link[2].codec_name = priv->dai_link[0].codec_name; priv->dai_link[2].cpu_of_node = cpu_np; priv->dai_link[2].dai_fmt = priv->dai_fmt; priv->card.num_links = 3; ret = of_property_read_u32(asrc_np, "fsl,asrc-rate", &priv->asrc_rate); if (ret) { dev_err(&pdev->dev, "failed to get output rate\n"); ret = -EINVAL; goto asrc_fail; } ret = of_property_read_u32(asrc_np, "fsl,asrc-width", &width); if (ret) { dev_err(&pdev->dev, "failed to get output rate\n"); ret = -EINVAL; goto asrc_fail; } if (width == 24) priv->asrc_format = SNDRV_PCM_FORMAT_S24_LE; else priv->asrc_format = SNDRV_PCM_FORMAT_S16_LE; } /* Finish card registering */ platform_set_drvdata(pdev, priv); snd_soc_card_set_drvdata(&priv->card, priv); ret = devm_snd_soc_register_card(&pdev->dev, &priv->card); if (ret) dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n", ret); asrc_fail: of_node_put(asrc_np); of_node_put(codec_np); fail: of_node_put(cpu_np); return ret; }
static int snd_cht_mc_probe(struct platform_device *pdev) { struct snd_soc_card *card = snd_soc_cards[0].soc_card; struct snd_soc_acpi_mach *mach; struct cht_mc_private *drv; const char *i2c_name = NULL; bool found = false; bool is_bytcr = false; int dai_index = 0; int ret_val = 0; int i; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; mach = (&pdev->dev)->platform_data; for (i = 0; i < ARRAY_SIZE(snd_soc_cards); i++) { if (acpi_dev_found(snd_soc_cards[i].codec_id) && (!strncmp(snd_soc_cards[i].codec_id, mach->id, 8))) { dev_dbg(&pdev->dev, "found codec %s\n", snd_soc_cards[i].codec_id); card = snd_soc_cards[i].soc_card; drv->acpi_card = &snd_soc_cards[i]; found = true; break; } } if (!found) { dev_err(&pdev->dev, "No matching HID found in supported list\n"); return -ENODEV; } card->dev = &pdev->dev; sprintf(drv->codec_name, "i2c-%s:00", drv->acpi_card->codec_id); /* set correct codec name */ for (i = 0; i < ARRAY_SIZE(cht_dailink); i++) if (!strcmp(card->dai_link[i].codec_name, "i2c-10EC5645:00")) { card->dai_link[i].codec_name = drv->codec_name; dai_index = i; } /* fixup codec name based on HID */ i2c_name = acpi_dev_get_first_match_name(mach->id, NULL, -1); if (i2c_name) { snprintf(cht_rt5645_codec_name, sizeof(cht_rt5645_codec_name), "%s%s", "i2c-", i2c_name); cht_dailink[dai_index].codec_name = cht_rt5645_codec_name; } /* * swap SSP0 if bytcr is detected * (will be overridden if DMI quirk is detected) */ if (is_valleyview()) { if (mach->mach_params.acpi_ipc_irq_index == 0) is_bytcr = true; } if (is_bytcr) { /* * Baytrail CR platforms may have CHAN package in BIOS, try * to find relevant routing quirk based as done on Windows * platforms. We have to read the information directly from the * BIOS, at this stage the card is not created and the links * with the codec driver/pdata are non-existent */ struct acpi_chan_package chan_package; /* format specified: 2 64-bit integers */ struct acpi_buffer format = {sizeof("NN"), "NN"}; struct acpi_buffer state = {0, NULL}; struct snd_soc_acpi_package_context pkg_ctx; bool pkg_found = false; state.length = sizeof(chan_package); state.pointer = &chan_package; pkg_ctx.name = "CHAN"; pkg_ctx.length = 2; pkg_ctx.format = &format; pkg_ctx.state = &state; pkg_ctx.data_valid = false; pkg_found = snd_soc_acpi_find_package_from_hid(mach->id, &pkg_ctx); if (pkg_found) { if (chan_package.aif_value == 1) { dev_info(&pdev->dev, "BIOS Routing: AIF1 connected\n"); cht_rt5645_quirk |= CHT_RT5645_SSP0_AIF1; } else if (chan_package.aif_value == 2) { dev_info(&pdev->dev, "BIOS Routing: AIF2 connected\n"); cht_rt5645_quirk |= CHT_RT5645_SSP0_AIF2; } else { dev_info(&pdev->dev, "BIOS Routing isn't valid, ignored\n"); pkg_found = false; } } if (!pkg_found) { /* no BIOS indications, assume SSP0-AIF2 connection */ cht_rt5645_quirk |= CHT_RT5645_SSP0_AIF2; } } /* check quirks before creating card */ dmi_check_system(cht_rt5645_quirk_table); log_quirks(&pdev->dev); if ((cht_rt5645_quirk & CHT_RT5645_SSP2_AIF2) || (cht_rt5645_quirk & CHT_RT5645_SSP0_AIF2)) { /* fixup codec aif name */ snprintf(cht_rt5645_codec_aif_name, sizeof(cht_rt5645_codec_aif_name), "%s", "rt5645-aif2"); cht_dailink[dai_index].codec_dai_name = cht_rt5645_codec_aif_name; } if ((cht_rt5645_quirk & CHT_RT5645_SSP0_AIF1) || (cht_rt5645_quirk & CHT_RT5645_SSP0_AIF2)) { /* fixup cpu dai name name */ snprintf(cht_rt5645_cpu_dai_name, sizeof(cht_rt5645_cpu_dai_name), "%s", "ssp0-port"); cht_dailink[dai_index].cpu_dai_name = cht_rt5645_cpu_dai_name; } drv->mclk = devm_clk_get(&pdev->dev, "pmc_plt_clk_3"); if (IS_ERR(drv->mclk)) { dev_err(&pdev->dev, "Failed to get MCLK from pmc_plt_clk_3: %ld\n", PTR_ERR(drv->mclk)); return PTR_ERR(drv->mclk); } snd_soc_card_set_drvdata(card, drv); ret_val = devm_snd_soc_register_card(&pdev->dev, card); if (ret_val) { dev_err(&pdev->dev, "snd_soc_register_card failed %d\n", ret_val); return ret_val; } platform_set_drvdata(pdev, card); return ret_val; }
static int rx51_soc_probe(struct platform_device *pdev) { struct rx51_audio_pdata *pdata; struct device_node *np = pdev->dev.of_node; struct snd_soc_card *card = &rx51_sound_card; int err; if (!machine_is_nokia_rx51() && !of_machine_is_compatible("nokia,omap3-n900")) return -ENODEV; card->dev = &pdev->dev; if (np) { struct device_node *dai_node; dai_node = of_parse_phandle(np, "nokia,cpu-dai", 0); if (!dai_node) { dev_err(&pdev->dev, "McBSP node is not provided\n"); return -EINVAL; } rx51_dai[0].cpu_dai_name = NULL; rx51_dai[0].platform_name = NULL; rx51_dai[0].cpu_of_node = dai_node; rx51_dai[0].platform_of_node = dai_node; dai_node = of_parse_phandle(np, "nokia,audio-codec", 0); if (!dai_node) { dev_err(&pdev->dev, "Codec node is not provided\n"); return -EINVAL; } rx51_dai[0].codec_name = NULL; rx51_dai[0].codec_of_node = dai_node; dai_node = of_parse_phandle(np, "nokia,audio-codec", 1); if (!dai_node) { dev_err(&pdev->dev, "Auxiliary Codec node is not provided\n"); return -EINVAL; } rx51_aux_dev[0].codec_name = NULL; rx51_aux_dev[0].codec_of_node = dai_node; rx51_codec_conf[0].dev_name = NULL; rx51_codec_conf[0].of_node = dai_node; dai_node = of_parse_phandle(np, "nokia,headphone-amplifier", 0); if (!dai_node) { dev_err(&pdev->dev, "Headphone amplifier node is not provided\n"); return -EINVAL; } /* TODO: tpa6130a2a driver supports only a single instance, so * this driver ignores the headphone-amplifier node for now. * It's already mandatory in the DT binding to be future proof. */ } pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); if (pdata == NULL) { dev_err(card->dev, "failed to create private data\n"); return -ENOMEM; } snd_soc_card_set_drvdata(card, pdata); pdata->tvout_selection_gpio = devm_gpiod_get(card->dev, "tvout-selection", GPIOD_OUT_LOW); if (IS_ERR(pdata->tvout_selection_gpio)) { dev_err(card->dev, "could not get tvout selection gpio\n"); return PTR_ERR(pdata->tvout_selection_gpio); } pdata->jack_detection_gpio = devm_gpiod_get(card->dev, "jack-detection", GPIOD_ASIS); if (IS_ERR(pdata->jack_detection_gpio)) { dev_err(card->dev, "could not get jack detection gpio\n"); return PTR_ERR(pdata->jack_detection_gpio); } pdata->eci_sw_gpio = devm_gpiod_get(card->dev, "eci-switch", GPIOD_OUT_HIGH); if (IS_ERR(pdata->eci_sw_gpio)) { dev_err(card->dev, "could not get eci switch gpio\n"); return PTR_ERR(pdata->eci_sw_gpio); } pdata->speaker_amp_gpio = devm_gpiod_get(card->dev, "speaker-amplifier", GPIOD_OUT_LOW); if (IS_ERR(pdata->speaker_amp_gpio)) { dev_err(card->dev, "could not get speaker enable gpio\n"); return PTR_ERR(pdata->speaker_amp_gpio); } err = devm_snd_soc_register_card(card->dev, card); if (err) { dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n", err); return err; } return 0; }
static int imx_wm8962_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; struct device_node *ssi_np, *codec_np; struct platform_device *ssi_pdev; struct imx_priv *priv = &card_priv; struct i2c_client *codec_dev; struct imx_wm8962_data *data; int int_port, ext_port; int ret; priv->pdev = pdev; ret = of_property_read_u32(np, "mux-int-port", &int_port); if (ret) { dev_err(&pdev->dev, "mux-int-port missing or invalid\n"); return ret; } ret = of_property_read_u32(np, "mux-ext-port", &ext_port); if (ret) { dev_err(&pdev->dev, "mux-ext-port missing or invalid\n"); return ret; } /* * The port numbering in the hardware manual starts at 1, while * the audmux API expects it starts at 0. */ int_port--; ext_port--; ret = imx_audmux_v2_configure_port(int_port, IMX_AUDMUX_V2_PTCR_SYN | IMX_AUDMUX_V2_PTCR_TFSEL(ext_port) | IMX_AUDMUX_V2_PTCR_TCSEL(ext_port) | IMX_AUDMUX_V2_PTCR_TFSDIR | IMX_AUDMUX_V2_PTCR_TCLKDIR, IMX_AUDMUX_V2_PDCR_RXDSEL(ext_port)); if (ret) { dev_err(&pdev->dev, "audmux internal port setup failed\n"); return ret; } ret = imx_audmux_v2_configure_port(ext_port, IMX_AUDMUX_V2_PTCR_SYN, IMX_AUDMUX_V2_PDCR_RXDSEL(int_port)); if (ret) { dev_err(&pdev->dev, "audmux external port setup failed\n"); return ret; } ssi_np = of_parse_phandle(pdev->dev.of_node, "ssi-controller", 0); codec_np = of_parse_phandle(pdev->dev.of_node, "audio-codec", 0); if (!ssi_np || !codec_np) { dev_err(&pdev->dev, "phandle missing or invalid\n"); ret = -EINVAL; goto fail; } ssi_pdev = of_find_device_by_node(ssi_np); if (!ssi_pdev) { dev_err(&pdev->dev, "failed to find SSI platform device\n"); ret = -EINVAL; goto fail; } codec_dev = of_find_i2c_device_by_node(codec_np); if (!codec_dev || !codec_dev->dev.driver) { dev_err(&pdev->dev, "failed to find codec platform device\n"); ret = -EINVAL; goto fail; } data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); if (!data) { ret = -ENOMEM; goto fail; } data->codec_clk = devm_clk_get(&codec_dev->dev, NULL); if (IS_ERR(data->codec_clk)) { ret = PTR_ERR(data->codec_clk); dev_err(&codec_dev->dev, "failed to get codec clk: %d\n", ret); goto fail; } data->clk_frequency = clk_get_rate(data->codec_clk); ret = clk_prepare_enable(data->codec_clk); if (ret) { dev_err(&codec_dev->dev, "failed to enable codec clk: %d\n", ret); goto fail; } data->dai.name = "HiFi"; data->dai.stream_name = "HiFi"; data->dai.codec_dai_name = "wm8962"; data->dai.codec_of_node = codec_np; data->dai.cpu_dai_name = dev_name(&ssi_pdev->dev); data->dai.platform_of_node = ssi_np; data->dai.ops = &imx_hifi_ops; data->dai.dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBM_CFM; data->card.dev = &pdev->dev; ret = snd_soc_of_parse_card_name(&data->card, "model"); if (ret) goto clk_fail; ret = snd_soc_of_parse_audio_routing(&data->card, "audio-routing"); if (ret) goto clk_fail; data->card.num_links = 1; data->card.owner = THIS_MODULE; data->card.dai_link = &data->dai; data->card.dapm_widgets = imx_wm8962_dapm_widgets; data->card.num_dapm_widgets = ARRAY_SIZE(imx_wm8962_dapm_widgets); data->card.late_probe = imx_wm8962_late_probe; data->card.set_bias_level = imx_wm8962_set_bias_level; platform_set_drvdata(pdev, &data->card); snd_soc_card_set_drvdata(&data->card, data); ret = devm_snd_soc_register_card(&pdev->dev, &data->card); if (ret) { dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n", ret); goto clk_fail; } of_node_put(ssi_np); of_node_put(codec_np); return 0; clk_fail: clk_disable_unprepare(data->codec_clk); fail: of_node_put(ssi_np); of_node_put(codec_np); return ret; }
static int mt2701_cs42448_machine_probe(struct platform_device *pdev) { struct snd_soc_card *card = &mt2701_cs42448_soc_card; int ret; int i; struct device_node *platform_node, *codec_node, *codec_node_bt_mrg; struct mt2701_cs42448_private *priv = devm_kzalloc(&pdev->dev, sizeof(struct mt2701_cs42448_private), GFP_KERNEL); struct device *dev = &pdev->dev; if (!priv) return -ENOMEM; platform_node = of_parse_phandle(pdev->dev.of_node, "mediatek,platform", 0); if (!platform_node) { dev_err(&pdev->dev, "Property 'platform' missing or invalid\n"); return -EINVAL; } for (i = 0; i < card->num_links; i++) { if (mt2701_cs42448_dai_links[i].platform_name) continue; mt2701_cs42448_dai_links[i].platform_of_node = platform_node; } card->dev = dev; codec_node = of_parse_phandle(pdev->dev.of_node, "mediatek,audio-codec", 0); if (!codec_node) { dev_err(&pdev->dev, "Property 'audio-codec' missing or invalid\n"); return -EINVAL; } for (i = 0; i < card->num_links; i++) { if (mt2701_cs42448_dai_links[i].codec_name) continue; mt2701_cs42448_dai_links[i].codec_of_node = codec_node; } codec_node_bt_mrg = of_parse_phandle(pdev->dev.of_node, "mediatek,audio-codec-bt-mrg", 0); if (!codec_node_bt_mrg) { dev_err(&pdev->dev, "Property 'audio-codec-bt-mrg' missing or invalid\n"); return -EINVAL; } mt2701_cs42448_dai_links[DAI_LINK_BE_MRG_BT].codec_of_node = codec_node_bt_mrg; ret = snd_soc_of_parse_audio_routing(card, "audio-routing"); if (ret) { dev_err(&pdev->dev, "failed to parse audio-routing: %d\n", ret); return ret; } priv->i2s1_in_mux_gpio_sel_1 = of_get_named_gpio(dev->of_node, "i2s1-in-sel-gpio1", 0); if (gpio_is_valid(priv->i2s1_in_mux_gpio_sel_1)) { ret = devm_gpio_request(dev, priv->i2s1_in_mux_gpio_sel_1, "i2s1_in_mux_gpio_sel_1"); if (ret) dev_warn(&pdev->dev, "%s devm_gpio_request fail %d\n", __func__, ret); gpio_direction_output(priv->i2s1_in_mux_gpio_sel_1, 0); } priv->i2s1_in_mux_gpio_sel_2 = of_get_named_gpio(dev->of_node, "i2s1-in-sel-gpio2", 0); if (gpio_is_valid(priv->i2s1_in_mux_gpio_sel_2)) { ret = devm_gpio_request(dev, priv->i2s1_in_mux_gpio_sel_2, "i2s1_in_mux_gpio_sel_2"); if (ret) dev_warn(&pdev->dev, "%s devm_gpio_request fail2 %d\n", __func__, ret); gpio_direction_output(priv->i2s1_in_mux_gpio_sel_2, 0); } snd_soc_card_set_drvdata(card, priv); ret = devm_snd_soc_register_card(&pdev->dev, card); if (ret) dev_err(&pdev->dev, "%s snd_soc_register_card fail %d\n", __func__, ret); return ret; }