[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 <linux/module.h>

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

#include "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 (IS_ERR(xtal)) {
			printk(KERN_ERR "%s cannot get xtal\n", __func__);
			ret = PTR_ERR(xtal);
		} else {
			pclk = clk_get(&s3c24xx_uda134x_snd_device->dev,
				       "pclk");
			if (IS_ERR(pclk)) {
				printk(KERN_ERR "%s cannot get pclk\n",
				       __func__);
				clk_put(xtal);
				ret = PTR_ERR(pclk);
			}
		}
		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_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",
	.dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
		   SND_SOC_DAIFMT_CBS_CFS,
	.ops = &s3c24xx_uda134x_ops,
	.platform_name	= "s3c24xx-iis",
};

static struct snd_soc_card snd_soc_s3c24xx_uda134x = {
	.name = "S3C24XX_UDA134X",
	.owner = THIS_MODULE,
	.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",
	},
};

module_platform_driver(s3c24xx_uda134x_driver);

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