[deliverable/linux.git] / sound / soc / samsung / s3c24xx_uda134x.c

/*
 * Modifications by Christian Pellegrin <chripell@evolware.org>
 *
 * s3c24xx_uda134x.c  --  S3C24XX_UDA134X ALSA SoC Audio board driver
 *
 * Copyright 2007 Dension Audio Systems Ltd.
 * Author: Zoltan Devai
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/clk.h>
#include <linux/gpio.h>

#include <sound/soc.h>
#include <sound/s3c24xx_uda134x.h>

#include <plat/regs-iis.h>

#include "s3c24xx-i2s.h"

/* #define ENFORCE_RATES 1 */
/*
  Unfortunately the S3C24XX in master mode has a limited capacity of
  generating the clock for the codec. If you define this only rates
  that are really available will be enforced. But be careful, most
  user level application just want the usual sampling frequencies (8,
  11.025, 22.050, 44.1 kHz) and anyway resampling is a costly
  operation for embedded systems. So if you aren't very lucky or your
  hardware engineer wasn't very forward-looking it's better to leave
  this undefined. If you do so an approximate value for the requested
  sampling rate in the range -/+ 5% will be chosen. If this in not
  possible an error will be returned.
*/

static struct clk *xtal;
static struct clk *pclk;
/* this is need because we don't have a place where to keep the
 * pointers to the clocks in each substream. We get the clocks only
 * when we are actually using them so we don't block stuff like
 * frequency change or oscillator power-off */
static int clk_users;
static DEFINE_MUTEX(clk_lock);

static unsigned int rates[33 * 2];
#ifdef ENFORCE_RATES
static struct snd_pcm_hw_constraint_list hw_constraints_rates = {
	.count	= ARRAY_SIZE(rates),
	.list	= rates,
	.mask	= 0,
};
#endif

static struct platform_device *s3c24xx_uda134x_snd_device;

static int s3c24xx_uda134x_startup(struct snd_pcm_substream *substream)
{
	int ret = 0;
#ifdef ENFORCE_RATES
	struct snd_pcm_runtime *runtime = substream->runtime;
#endif

	mutex_lock(&clk_lock);
	pr_debug("%s %d\n", __func__, clk_users);
	if (clk_users == 0) {
		xtal = clk_get(&s3c24xx_uda134x_snd_device->dev, "xtal");
		if (!xtal) {
			printk(KERN_ERR "%s cannot get xtal\n", __func__);
			ret = -EBUSY;
		} else {
			pclk = clk_get(&s3c24xx_uda134x_snd_device->dev,
				       "pclk");
			if (!pclk) {
				printk(KERN_ERR "%s cannot get pclk\n",
				       __func__);
				clk_put(xtal);
				ret = -EBUSY;
			}
		}
		if (!ret) {
			int i, j;

			for (i = 0; i < 2; i++) {
				int fs = i ? 256 : 384;

				rates[i*33] = clk_get_rate(xtal) / fs;
				for (j = 1; j < 33; j++)
					rates[i*33 + j] = clk_get_rate(pclk) /
						(j * fs);
			}
		}
	}
	clk_users += 1;
	mutex_unlock(&clk_lock);
	if (!ret) {
#ifdef ENFORCE_RATES
		ret = snd_pcm_hw_constraint_list(runtime, 0,
						 SNDRV_PCM_HW_PARAM_RATE,
						 &hw_constraints_rates);
		if (ret < 0)
			printk(KERN_ERR "%s cannot set constraints\n",
			       __func__);
#endif
	}
	return ret;
}

static void s3c24xx_uda134x_shutdown(struct snd_pcm_substream *substream)
{
	mutex_lock(&clk_lock);
	pr_debug("%s %d\n", __func__, clk_users);
	clk_users -= 1;
	if (clk_users == 0) {
		clk_put(xtal);
		xtal = NULL;
		clk_put(pclk);
		pclk = NULL;
	}
	mutex_unlock(&clk_lock);
}

static int s3c24xx_uda134x_hw_params(struct snd_pcm_substream *substream,
					struct snd_pcm_hw_params *params)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_dai *codec_dai = rtd->codec_dai;
	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
	unsigned int clk = 0;
	int ret = 0;
	int clk_source, fs_mode;
	unsigned long rate = params_rate(params);
	long err, cerr;
	unsigned int div;
	int i, bi;

	err = 999999;
	bi = 0;
	for (i = 0; i < 2*33; i++) {
		cerr = rates[i] - rate;
		if (cerr < 0)
			cerr = -cerr;
		if (cerr < err) {
			err = cerr;
			bi = i;
		}
	}
	if (bi / 33 == 1)
		fs_mode = S3C2410_IISMOD_256FS;
	else
		fs_mode = S3C2410_IISMOD_384FS;
	if (bi % 33 == 0) {
		clk_source = S3C24XX_CLKSRC_MPLL;
		div = 1;
	} else {
		clk_source = S3C24XX_CLKSRC_PCLK;
		div = bi % 33;
	}
	pr_debug("%s desired rate %lu, %d\n", __func__, rate, bi);

	clk = (fs_mode == S3C2410_IISMOD_384FS ? 384 : 256) * rate;
	pr_debug("%s will use: %s %s %d sysclk %d err %ld\n", __func__,
		 fs_mode == S3C2410_IISMOD_384FS ? "384FS" : "256FS",
		 clk_source == S3C24XX_CLKSRC_MPLL ? "MPLLin" : "PCLK",
		 div, clk, err);

	if ((err * 100 / rate) > 5) {
		printk(KERN_ERR "S3C24XX_UDA134X: effective frequency "
		       "too different from desired (%ld%%)\n",
		       err * 100 / rate);
		return -EINVAL;
	}

	ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
			SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
	if (ret < 0)
		return ret;

	ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
			SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
	if (ret < 0)
		return ret;

	ret = snd_soc_dai_set_sysclk(cpu_dai, clk_source , clk,
			SND_SOC_CLOCK_IN);
	if (ret < 0)
		return ret;

	ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_MCLK, fs_mode);
	if (ret < 0)
		return ret;

	ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_BCLK,
			S3C2410_IISMOD_32FS);
	if (ret < 0)
		return ret;

	ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_PRESCALER,
			S3C24XX_PRESCALE(div, div));
	if (ret < 0)
		return ret;

	/* set the codec system clock for DAC and ADC */
	ret = snd_soc_dai_set_sysclk(codec_dai, 0, clk,
			SND_SOC_CLOCK_OUT);
	if (ret < 0)
		return ret;

	return 0;
}

static struct snd_soc_ops s3c24xx_uda134x_ops = {
	.startup = s3c24xx_uda134x_startup,
	.shutdown = s3c24xx_uda134x_shutdown,
	.hw_params = s3c24xx_uda134x_hw_params,
};

static struct snd_soc_dai_link s3c24xx_uda134x_dai_link = {
	.name = "UDA134X",
	.stream_name = "UDA134X",
	.codec_name = "uda134x-codec",
	.codec_dai_name = "uda134x-hifi",
	.cpu_dai_name = "s3c24xx-iis",
	.ops = &s3c24xx_uda134x_ops,
	.platform_name	= "samsung-audio",
};

static struct snd_soc_card snd_soc_s3c24xx_uda134x = {
	.name = "S3C24XX_UDA134X",
	.dai_link = &s3c24xx_uda134x_dai_link,
	.num_links = 1,
};

static struct s3c24xx_uda134x_platform_data *s3c24xx_uda134x_l3_pins;

static void setdat(int v)
{
	gpio_set_value(s3c24xx_uda134x_l3_pins->l3_data, v > 0);
}

static void setclk(int v)
{
	gpio_set_value(s3c24xx_uda134x_l3_pins->l3_clk, v > 0);
}

static void setmode(int v)
{
	gpio_set_value(s3c24xx_uda134x_l3_pins->l3_mode, v > 0);
}

/* FIXME - This must be codec platform data but in which board file ?? */
static struct uda134x_platform_data s3c24xx_uda134x = {
	.l3 = {
		.setdat = setdat,
		.setclk = setclk,
		.setmode = setmode,
		.data_hold = 1,
		.data_setup = 1,
		.clock_high = 1,
		.mode_hold = 1,
		.mode = 1,
		.mode_setup = 1,
	},
};

static int s3c24xx_uda134x_setup_pin(int pin, char *fun)
{
	if (gpio_request(pin, "s3c24xx_uda134x") < 0) {
		printk(KERN_ERR "S3C24XX_UDA134X SoC Audio: "
		       "l3 %s pin already in use", fun);
		return -EBUSY;
	}
	gpio_direction_output(pin, 0);
	return 0;
}

static int s3c24xx_uda134x_probe(struct platform_device *pdev)
{
	int ret;

	printk(KERN_INFO "S3C24XX_UDA134X SoC Audio driver\n");

	s3c24xx_uda134x_l3_pins = pdev->dev.platform_data;
	if (s3c24xx_uda134x_l3_pins == NULL) {
		printk(KERN_ERR "S3C24XX_UDA134X SoC Audio: "
		       "unable to find platform data\n");
		return -ENODEV;
	}
	s3c24xx_uda134x.power = s3c24xx_uda134x_l3_pins->power;
	s3c24xx_uda134x.model = s3c24xx_uda134x_l3_pins->model;

	if (s3c24xx_uda134x_setup_pin(s3c24xx_uda134x_l3_pins->l3_data,
				      "data") < 0)
		return -EBUSY;
	if (s3c24xx_uda134x_setup_pin(s3c24xx_uda134x_l3_pins->l3_clk,
				      "clk") < 0) {
		gpio_free(s3c24xx_uda134x_l3_pins->l3_data);
		return -EBUSY;
	}
	if (s3c24xx_uda134x_setup_pin(s3c24xx_uda134x_l3_pins->l3_mode,
				      "mode") < 0) {
		gpio_free(s3c24xx_uda134x_l3_pins->l3_data);
		gpio_free(s3c24xx_uda134x_l3_pins->l3_clk);
		return -EBUSY;
	}

	s3c24xx_uda134x_snd_device = platform_device_alloc("soc-audio", -1);
	if (!s3c24xx_uda134x_snd_device) {
		printk(KERN_ERR "S3C24XX_UDA134X SoC Audio: "
		       "Unable to register\n");
		return -ENOMEM;
	}

	platform_set_drvdata(s3c24xx_uda134x_snd_device,
			     &snd_soc_s3c24xx_uda134x);
	platform_device_add_data(s3c24xx_uda134x_snd_device, &s3c24xx_uda134x, sizeof(s3c24xx_uda134x));
	ret = platform_device_add(s3c24xx_uda134x_snd_device);
	if (ret) {
		printk(KERN_ERR "S3C24XX_UDA134X SoC Audio: Unable to add\n");
		platform_device_put(s3c24xx_uda134x_snd_device);
	}

	return ret;
}

static int s3c24xx_uda134x_remove(struct platform_device *pdev)
{
	platform_device_unregister(s3c24xx_uda134x_snd_device);
	gpio_free(s3c24xx_uda134x_l3_pins->l3_data);
	gpio_free(s3c24xx_uda134x_l3_pins->l3_clk);
	gpio_free(s3c24xx_uda134x_l3_pins->l3_mode);
	return 0;
}

static struct platform_driver s3c24xx_uda134x_driver = {
	.probe  = s3c24xx_uda134x_probe,
	.remove = s3c24xx_uda134x_remove,
	.driver = {
		.name = "s3c24xx_uda134x",
		.owner = THIS_MODULE,
	},
};

static int __init s3c24xx_uda134x_init(void)
{
	return platform_driver_register(&s3c24xx_uda134x_driver);
}

static void __exit s3c24xx_uda134x_exit(void)
{
	platform_driver_unregister(&s3c24xx_uda134x_driver);
}


module_init(s3c24xx_uda134x_init);
module_exit(s3c24xx_uda134x_exit);

MODULE_AUTHOR("Zoltan Devai, Christian Pellegrin <chripell@evolware.org>");
MODULE_DESCRIPTION("S3C24XX_UDA134X ALSA SoC audio driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
7ad933d7 CP	1	/*
	2	* Modifications by Christian Pellegrin <chripell@evolware.org>
	3	*
	4	* s3c24xx_uda134x.c -- S3C24XX_UDA134X ALSA SoC Audio board driver
	5	*
	6	* Copyright 2007 Dension Audio Systems Ltd.
	7	* Author: Zoltan Devai
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License version 2 as
	11	* published by the Free Software Foundation.
	12	*/
	13
7ad933d7	14	#include <linux/clk.h>
7ad933d7	15	#include <linux/gpio.h>
0378b6ac	16
7ad933d7	17	#include <sound/soc.h>
7ad933d7	18	#include <sound/s3c24xx_uda134x.h>
7ad933d7	19
8150bc88	20	#include <plat/regs-iis.h>
7ad933d7	21
7ad933d7	22	#include "s3c24xx-i2s.h"
7ad933d7 CP	23
	24	/* #define ENFORCE_RATES 1 */
	25	/*
	26	Unfortunately the S3C24XX in master mode has a limited capacity of
	27	generating the clock for the codec. If you define this only rates
	28	that are really available will be enforced. But be careful, most
	29	user level application just want the usual sampling frequencies (8,
	30	11.025, 22.050, 44.1 kHz) and anyway resampling is a costly
	31	operation for embedded systems. So if you aren't very lucky or your
	32	hardware engineer wasn't very forward-looking it's better to leave
	33	this undefined. If you do so an approximate value for the requested
	34	sampling rate in the range -/+ 5% will be chosen. If this in not
	35	possible an error will be returned.
	36	*/
	37
	38	static struct clk *xtal;
	39	static struct clk *pclk;
	40	/* this is need because we don't have a place where to keep the
	41	* pointers to the clocks in each substream. We get the clocks only
	42	* when we are actually using them so we don't block stuff like
	43	* frequency change or oscillator power-off */
	44	static int clk_users;
	45	static DEFINE_MUTEX(clk_lock);
	46
	47	static unsigned int rates[33 * 2];
	48	#ifdef ENFORCE_RATES
	49	static struct snd_pcm_hw_constraint_list hw_constraints_rates = {
	50	.count = ARRAY_SIZE(rates),
	51	.list = rates,
	52	.mask = 0,
	53	};
	54	#endif
	55
	56	static struct platform_device *s3c24xx_uda134x_snd_device;
	57
d0c36631	58	static int s3c24xx_uda134x_startup(struct snd_pcm_substream *substream)
7ad933d7 CP	59	{
	60	int ret = 0;
	61	#ifdef ENFORCE_RATES
a419aef8	62	struct snd_pcm_runtime *runtime = substream->runtime;
7ad933d7 CP	63	#endif
	64
	65	mutex_lock(&clk_lock);
	66	pr_debug("%s %d\n", __func__, clk_users);
	67	if (clk_users == 0) {
	68	xtal = clk_get(&s3c24xx_uda134x_snd_device->dev, "xtal");
	69	if (!xtal) {
	70	printk(KERN_ERR "%s cannot get xtal\n", __func__);
	71	ret = -EBUSY;
	72	} else {
	73	pclk = clk_get(&s3c24xx_uda134x_snd_device->dev,
	74	"pclk");
	75	if (!pclk) {
	76	printk(KERN_ERR "%s cannot get pclk\n",
	77	__func__);
	78	clk_put(xtal);
	79	ret = -EBUSY;
	80	}
	81	}
	82	if (!ret) {
	83	int i, j;
	84
	85	for (i = 0; i < 2; i++) {
	86	int fs = i ? 256 : 384;
	87
	88	rates[i*33] = clk_get_rate(xtal) / fs;
	89	for (j = 1; j < 33; j++)
	90	rates[i*33 + j] = clk_get_rate(pclk) /
	91	(j * fs);
	92	}
	93	}
	94	}
	95	clk_users += 1;
	96	mutex_unlock(&clk_lock);
	97	if (!ret) {
	98	#ifdef ENFORCE_RATES
	99	ret = snd_pcm_hw_constraint_list(runtime, 0,
	100	SNDRV_PCM_HW_PARAM_RATE,
	101	&hw_constraints_rates);
	102	if (ret < 0)
	103	printk(KERN_ERR "%s cannot set constraints\n",
	104	__func__);
	105	#endif
	106	}
	107	return ret;
	108	}
	109
d0c36631	110	static void s3c24xx_uda134x_shutdown(struct snd_pcm_substream *substream)
7ad933d7 CP	111	{
	112	mutex_lock(&clk_lock);
	113	pr_debug("%s %d\n", __func__, clk_users);
	114	clk_users -= 1;
	115	if (clk_users == 0) {
	116	clk_put(xtal);
	117	xtal = NULL;
	118	clk_put(pclk);
	119	pclk = NULL;
	120	}
	121	mutex_unlock(&clk_lock);
	122	}
	123
	124	static int s3c24xx_uda134x_hw_params(struct snd_pcm_substream *substream,
	125	struct snd_pcm_hw_params *params)
	126	{
	127	struct snd_soc_pcm_runtime *rtd = substream->private_data;
f0fba2ad LG	128	struct snd_soc_dai *codec_dai = rtd->codec_dai;
f0fba2ad LG	129	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
7ad933d7 CP	130	unsigned int clk = 0;
	131	int ret = 0;
	132	int clk_source, fs_mode;
	133	unsigned long rate = params_rate(params);
	134	long err, cerr;
	135	unsigned int div;
	136	int i, bi;
	137
	138	err = 999999;
	139	bi = 0;
	140	for (i = 0; i < 2*33; i++) {
	141	cerr = rates[i] - rate;
	142	if (cerr < 0)
	143	cerr = -cerr;
	144	if (cerr < err) {
	145	err = cerr;
	146	bi = i;
	147	}
	148	}
	149	if (bi / 33 == 1)
	150	fs_mode = S3C2410_IISMOD_256FS;
	151	else
	152	fs_mode = S3C2410_IISMOD_384FS;
	153	if (bi % 33 == 0) {
	154	clk_source = S3C24XX_CLKSRC_MPLL;
	155	div = 1;
	156	} else {
	157	clk_source = S3C24XX_CLKSRC_PCLK;
	158	div = bi % 33;
	159	}
	160	pr_debug("%s desired rate %lu, %d\n", __func__, rate, bi);
	161
	162	clk = (fs_mode == S3C2410_IISMOD_384FS ? 384 : 256) * rate;
	163	pr_debug("%s will use: %s %s %d sysclk %d err %ld\n", __func__,
	164	fs_mode == S3C2410_IISMOD_384FS ? "384FS" : "256FS",
	165	clk_source == S3C24XX_CLKSRC_MPLL ? "MPLLin" : "PCLK",
	166	div, clk, err);
	167
	168	if ((err * 100 / rate) > 5) {
	169	printk(KERN_ERR "S3C24XX_UDA134X: effective frequency "
	170	"too different from desired (%ld%%)\n",
	171	err * 100 / rate);
	172	return -EINVAL;
	173	}
	174
d0c36631	175	ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S \|
7ad933d7 CP	176	SND_SOC_DAIFMT_NB_NF \| SND_SOC_DAIFMT_CBS_CFS);
	177	if (ret < 0)
	178	return ret;
	179
d0c36631	180	ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S \|
7ad933d7 CP	181	SND_SOC_DAIFMT_NB_NF \| SND_SOC_DAIFMT_CBS_CFS);
	182	if (ret < 0)
	183	return ret;
	184
d0c36631 MB	185	ret = snd_soc_dai_set_sysclk(cpu_dai, clk_source , clk,
d0c36631 MB	186	SND_SOC_CLOCK_IN);
7ad933d7 CP	187	if (ret < 0)
	188	return ret;
	189
d0c36631	190	ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_MCLK, fs_mode);
7ad933d7 CP	191	if (ret < 0)
	192	return ret;
	193
d0c36631 MB	194	ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_BCLK,
d0c36631 MB	195	S3C2410_IISMOD_32FS);
7ad933d7 CP	196	if (ret < 0)
	197	return ret;
	198
d0c36631 MB	199	ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_PRESCALER,
d0c36631 MB	200	S3C24XX_PRESCALE(div, div));
7ad933d7 CP	201	if (ret < 0)
	202	return ret;
	203
	204	/* set the codec system clock for DAC and ADC */
d0c36631 MB	205	ret = snd_soc_dai_set_sysclk(codec_dai, 0, clk,
d0c36631 MB	206	SND_SOC_CLOCK_OUT);
7ad933d7 CP	207	if (ret < 0)
	208	return ret;
	209
	210	return 0;
	211	}
	212
	213	static struct snd_soc_ops s3c24xx_uda134x_ops = {
	214	.startup = s3c24xx_uda134x_startup,
	215	.shutdown = s3c24xx_uda134x_shutdown,
	216	.hw_params = s3c24xx_uda134x_hw_params,
	217	};
	218
	219	static struct snd_soc_dai_link s3c24xx_uda134x_dai_link = {
	220	.name = "UDA134X",
	221	.stream_name = "UDA134X",
a110f4ef	222	.codec_name = "uda134x-codec",
f0fba2ad	223	.codec_dai_name = "uda134x-hifi",
518aa59f	224	.cpu_dai_name = "s3c24xx-iis",
7ad933d7	225	.ops = &s3c24xx_uda134x_ops,
58bb4072	226	.platform_name = "samsung-audio",
7ad933d7 CP	227	};
7ad933d7 CP	228
87506549	229	static struct snd_soc_card snd_soc_s3c24xx_uda134x = {
7ad933d7 CP	230	.name = "S3C24XX_UDA134X",
	231	.dai_link = &s3c24xx_uda134x_dai_link,
	232	.num_links = 1,
	233	};
	234
	235	static struct s3c24xx_uda134x_platform_data *s3c24xx_uda134x_l3_pins;
	236
	237	static void setdat(int v)
	238	{
	239	gpio_set_value(s3c24xx_uda134x_l3_pins->l3_data, v > 0);
	240	}
	241
	242	static void setclk(int v)
	243	{
	244	gpio_set_value(s3c24xx_uda134x_l3_pins->l3_clk, v > 0);
	245	}
	246
	247	static void setmode(int v)
	248	{
	249	gpio_set_value(s3c24xx_uda134x_l3_pins->l3_mode, v > 0);
	250	}
	251
f0fba2ad	252	/* FIXME - This must be codec platform data but in which board file ?? */
7ad933d7 CP	253	static struct uda134x_platform_data s3c24xx_uda134x = {
	254	.l3 = {
	255	.setdat = setdat,
	256	.setclk = setclk,
	257	.setmode = setmode,
	258	.data_hold = 1,
	259	.data_setup = 1,
	260	.clock_high = 1,
	261	.mode_hold = 1,
	262	.mode = 1,
	263	.mode_setup = 1,
	264	},
	265	};
	266
7ad933d7 CP	267	static int s3c24xx_uda134x_setup_pin(int pin, char *fun)
	268	{
	269	if (gpio_request(pin, "s3c24xx_uda134x") < 0) {
	270	printk(KERN_ERR "S3C24XX_UDA134X SoC Audio: "
	271	"l3 %s pin already in use", fun);
	272	return -EBUSY;
	273	}
	274	gpio_direction_output(pin, 0);
	275	return 0;
	276	}
	277
	278	static int s3c24xx_uda134x_probe(struct platform_device *pdev)
	279	{
	280	int ret;
	281
	282	printk(KERN_INFO "S3C24XX_UDA134X SoC Audio driver\n");
	283
	284	s3c24xx_uda134x_l3_pins = pdev->dev.platform_data;
	285	if (s3c24xx_uda134x_l3_pins == NULL) {
	286	printk(KERN_ERR "S3C24XX_UDA134X SoC Audio: "
	287	"unable to find platform data\n");
	288	return -ENODEV;
	289	}
	290	s3c24xx_uda134x.power = s3c24xx_uda134x_l3_pins->power;
	291	s3c24xx_uda134x.model = s3c24xx_uda134x_l3_pins->model;
	292
	293	if (s3c24xx_uda134x_setup_pin(s3c24xx_uda134x_l3_pins->l3_data,
	294	"data") < 0)
	295	return -EBUSY;
	296	if (s3c24xx_uda134x_setup_pin(s3c24xx_uda134x_l3_pins->l3_clk,
	297	"clk") < 0) {
	298	gpio_free(s3c24xx_uda134x_l3_pins->l3_data);
	299	return -EBUSY;
	300	}
	301	if (s3c24xx_uda134x_setup_pin(s3c24xx_uda134x_l3_pins->l3_mode,
	302	"mode") < 0) {
	303	gpio_free(s3c24xx_uda134x_l3_pins->l3_data);
	304	gpio_free(s3c24xx_uda134x_l3_pins->l3_clk);
	305	return -EBUSY;
	306	}
	307
	308	s3c24xx_uda134x_snd_device = platform_device_alloc("soc-audio", -1);
	309	if (!s3c24xx_uda134x_snd_device) {
	310	printk(KERN_ERR "S3C24XX_UDA134X SoC Audio: "
	311	"Unable to register\n");
	312	return -ENOMEM;
	313	}
	314
	315	platform_set_drvdata(s3c24xx_uda134x_snd_device,
f0fba2ad	316	&snd_soc_s3c24xx_uda134x);
a110f4ef	317	platform_device_add_data(s3c24xx_uda134x_snd_device, &s3c24xx_uda134x, sizeof(s3c24xx_uda134x));
7ad933d7 CP	318	ret = platform_device_add(s3c24xx_uda134x_snd_device);
	319	if (ret) {
	320	printk(KERN_ERR "S3C24XX_UDA134X SoC Audio: Unable to add\n");
	321	platform_device_put(s3c24xx_uda134x_snd_device);
	322	}
	323
	324	return ret;
	325	}
	326
	327	static int s3c24xx_uda134x_remove(struct platform_device *pdev)
	328	{
	329	platform_device_unregister(s3c24xx_uda134x_snd_device);
	330	gpio_free(s3c24xx_uda134x_l3_pins->l3_data);
	331	gpio_free(s3c24xx_uda134x_l3_pins->l3_clk);
	332	gpio_free(s3c24xx_uda134x_l3_pins->l3_mode);
	333	return 0;
	334	}
	335
	336	static struct platform_driver s3c24xx_uda134x_driver = {
	337	.probe = s3c24xx_uda134x_probe,
	338	.remove = s3c24xx_uda134x_remove,
	339	.driver = {
	340	.name = "s3c24xx_uda134x",
	341	.owner = THIS_MODULE,
	342	},
	343	};
	344
	345	static int __init s3c24xx_uda134x_init(void)
	346	{
	347	return platform_driver_register(&s3c24xx_uda134x_driver);
	348	}
	349
	350	static void __exit s3c24xx_uda134x_exit(void)
	351	{
	352	platform_driver_unregister(&s3c24xx_uda134x_driver);
	353	}
	354
	355
	356	module_init(s3c24xx_uda134x_init);
	357	module_exit(s3c24xx_uda134x_exit);
	358
	359	MODULE_AUTHOR("Zoltan Devai, Christian Pellegrin <chripell@evolware.org>");
	360	MODULE_DESCRIPTION("S3C24XX_UDA134X ALSA SoC audio driver");
	361	MODULE_LICENSE("GPL");