[deliverable/linux.git] / sound / soc / s3c24xx / 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/module.h>
#include <linux/clk.h>
#include <linux/mutex.h>
#include <linux/gpio.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <sound/soc-dapm.h>
#include <sound/s3c24xx_uda134x.h>
#include <sound/uda134x.h>

#include <plat/regs-iis.h>

#include "s3c-dma.h"
#include "s3c24xx-i2s.h"
#include "../codecs/uda134x.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->dai->codec_dai;
	struct snd_soc_dai *cpu_dai = rtd->dai->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_dai = &uda134x_dai,
	.cpu_dai = &s3c24xx_i2s_dai,
	.ops = &s3c24xx_uda134x_ops,
};

static struct snd_soc_card snd_soc_s3c24xx_uda134x = {
	.name = "S3C24XX_UDA134X",
	.platform = &s3c24xx_soc_platform,
	.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);
}

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 struct snd_soc_device s3c24xx_uda134x_snd_devdata = {
	.card = &snd_soc_s3c24xx_uda134x,
	.codec_dev = &soc_codec_dev_uda134x,
	.codec_data = &s3c24xx_uda134x,
};

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