ASoC: davinci-evm: Add device tree binding

* Texas Instruments SoC audio setups with TLV320AIC3X Codec

Required properties:

- compatible : "ti,da830-evm-audio" : forDM365/DA8xx/OMAPL1x/AM33xx

- ti,model : The user-visible name of this sound complex.

- ti,audio-codec : The phandle of the TLV320AIC3x audio codec

- ti,mcasp-controller : The phandle of the McASP controller

- ti,codec-clock-rate : The Codec Clock rate (in Hz) applied to the Codec

- ti,audio-routing : A list of the connections between audio components.

  Each entry is a pair of strings, the first being the connection's sink,

  the second being the connection's source. Valid names for sources and

  sinks are the codec's pins, and the jacks on the board:

  Board connectors:

  * Headphone Jack

  * Line Out

  * Mic Jack

  * Line In

Example:

sound {

	compatible = "ti,da830-evm-audio";

	ti,model = "DA830 EVM";

	ti,audio-codec = <&tlv320aic3x>;

	ti,mcasp-controller = <&mcasp1>;

	ti,codec-clock-rate = <12000000>;

	ti,audio-routing =

		"Headphone Jack",       "HPLOUT",

		"Headphone Jack",       "HPROUT",

		"Line Out",             "LLOUT",

		"Line Out",             "RLOUT",

		"MIC3L",                "Mic Bias 2V",

		"MIC3R",                "Mic Bias 2V",

		"Mic Bias 2V",          "Mic Jack",

		"LINE1L",               "Line In",

		"LINE2L",               "Line In",

		"LINE1R",               "Line In",

		"LINE2R",               "Line In";

};

#include <linux/platform_device.h>

#include <linux/platform_data/edma.h>

#include <linux/i2c.h>

#include <linux/of_platform.h>

#include <sound/core.h>

#include <sound/pcm.h>

#include <sound/soc.h>

#include <asm/dma.h>

#include <asm/mach-types.h>

#include <linux/edma.h>

#include "davinci-pcm.h"

#include "davinci-i2s.h"

#include "davinci-mcasp.h"

{

	struct snd_soc_codec *codec = rtd->codec;

	struct snd_soc_dapm_context *dapm = &codec->dapm;

	struct device_node *np = codec->card->dev->of_node;

	int ret;

	/* Add davinci-evm specific widgets */

	snd_soc_dapm_new_controls(dapm, aic3x_dapm_widgets,

				  ARRAY_SIZE(aic3x_dapm_widgets));

	if (np) {

		ret = snd_soc_of_parse_audio_routing(codec->card,

							"ti,audio-routing");

		if (ret)

			return ret;

	} else {

		/* Set up davinci-evm specific audio path audio_map */

		snd_soc_dapm_add_routes(dapm, audio_map, ARRAY_SIZE(audio_map));

	}

	/* not connected */

	snd_soc_dapm_disable_pin(dapm, "MONO_LOUT");

	.drvdata = &da850_snd_soc_card_drvdata,

};

#if defined(CONFIG_OF)

/*

 * The struct is used as place holder. It will be completely

 * filled with data from dt node.

 */

static struct snd_soc_dai_link evm_dai_tlv320aic3x = {

	.name		= "TLV320AIC3X",

	.stream_name	= "AIC3X",

	.codec_dai_name	= "tlv320aic3x-hifi",

	.ops            = &evm_ops,

	.init           = evm_aic3x_init,

};

static const struct of_device_id davinci_evm_dt_ids[] = {

	{

		.compatible = "ti,da830-evm-audio",

		.data = (void *) &evm_dai_tlv320aic3x,

	},

	{ /* sentinel */ }

};

MODULE_DEVICE_TABLE(of, davinci_evm_dt_ids);

/* davinci evm audio machine driver */

static struct snd_soc_card evm_soc_card = {

	.owner = THIS_MODULE,

	.num_links = 1,

};

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 davinci_evm_remove(struct platform_device *pdev)

{

	struct snd_soc_card *card = platform_get_drvdata(pdev);

	snd_soc_unregister_card(card);

	return 0;

}

static struct platform_driver davinci_evm_driver = {

	.probe		= davinci_evm_probe,

	.remove		= davinci_evm_remove,

	.driver		= {

		.name	= "davinci_evm",

		.owner	= THIS_MODULE,

		.of_match_table = of_match_ptr(davinci_evm_dt_ids),

	},

};

#endif

static struct platform_device *evm_snd_device;

static int __init evm_init(void)

	int index;

	int ret;

	/*

	 * If dtb is there, the devices will be created dynamically.

	 * Only register platfrom driver structure.

	 */

#if defined(CONFIG_OF)

	if (of_have_populated_dt())

		return platform_driver_register(&davinci_evm_driver);

#endif

	if (machine_is_davinci_evm()) {

		evm_snd_dev_data = &dm6446_snd_soc_card_evm;

		index = 0;

static void __exit evm_exit(void)

{

#if defined(CONFIG_OF)

	if (of_have_populated_dt()) {

		platform_driver_unregister(&davinci_evm_driver);

		return;

	}

#endif

	platform_device_unregister(evm_snd_device);

}