875065491f
One of the issues with the ASoC v1 API which has been addressed in the ASoC v2 work that Liam Girdwood has done is that the ALSA card provided by ASoC is distributed around the ASoC structures. For example, machine wide data such as the struct snd_card are maintained as part of the CODEC data structure, preventing the use of multiple codecs. This has been addressed by refactoring the data structures so that all the data for the ALSA card is contained in a single structure snd_soc_card which replaces the existing snd_soc_machine and snd_soc_device. Begin the process of backporting this by renaming struct snd_soc_machine to struct snd_soc_card, better reflecting its function and bringing it closer to standard ALSA terminology. Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
373 lines
9.5 KiB
C
373 lines
9.5 KiB
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 <asm/plat-s3c24xx/regs-iis.h>
|
|
|
|
#include "s3c24xx-pcm.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",
|
|
.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,
|
|
.platform = &s3c24xx_soc_platform,
|
|
.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");
|