Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit bf557a50 authored by Mark Brown's avatar Mark Brown
Browse files

Merge branch 'for-2.6.37' of... 

Merge branch 'for-2.6.37' of git://git.kernel.org/pub/scm/linux/kernel/git/lrg/asoc-2.6 into for-2.6.37
parents 26b01ccd 3fabe089

sound/soc/codecs/wl1273.c

0 → 100644
+525 −0
Original line number Original line Diff line number Diff line 
/*

 * ALSA SoC WL1273 codec driver

 *

 * Author:      Matti Aaltonen, <matti.j.aaltonen@nokia.com>

 *

 * Copyright:   (C) 2010 Nokia Corporation

 *

 * 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.

 *

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

 * 02110-1301 USA

 *

 */



#include <linux/mfd/wl1273-core.h>

#include <linux/slab.h>

#include <sound/pcm.h>

#include <sound/pcm_params.h>

#include <sound/soc-dai.h>

#include <sound/soc-dapm.h>

#include <sound/initval.h>



#include "wl1273.h"



enum wl1273_mode { WL1273_MODE_BT, WL1273_MODE_FM_RX, WL1273_MODE_FM_TX };



/* codec private data */

struct wl1273_priv {

	enum wl1273_mode mode;

	struct wl1273_core *core;

	unsigned int channels;

};



static int snd_wl1273_fm_set_i2s_mode(struct wl1273_core *core,

				      int rate, int width)

{

	struct device *dev = &core->i2c_dev->dev;

	int r = 0;

	u16 mode;



	dev_dbg(dev, "rate: %d\n", rate);

	dev_dbg(dev, "width: %d\n", width);



	mutex_lock(&core->lock);



	mode = core->i2s_mode & ~WL1273_IS2_WIDTH & ~WL1273_IS2_RATE;



	switch (rate) {

	case 48000:

		mode |= WL1273_IS2_RATE_48K;

		break;

	case 44100:

		mode |= WL1273_IS2_RATE_44_1K;

		break;

	case 32000:

		mode |= WL1273_IS2_RATE_32K;

		break;

	case 22050:

		mode |= WL1273_IS2_RATE_22_05K;

		break;

	case 16000:

		mode |= WL1273_IS2_RATE_16K;

		break;

	case 12000:

		mode |= WL1273_IS2_RATE_12K;

		break;

	case 11025:

		mode |= WL1273_IS2_RATE_11_025;

		break;

	case 8000:

		mode |= WL1273_IS2_RATE_8K;

		break;

	default:

		dev_err(dev, "Sampling rate: %d not supported\n", rate);

		r = -EINVAL;

		goto out;

	}



	switch (width) {

	case 16:

		mode |= WL1273_IS2_WIDTH_32;

		break;

	case 20:

		mode |= WL1273_IS2_WIDTH_40;

		break;

	case 24:

		mode |= WL1273_IS2_WIDTH_48;

		break;

	case 25:

		mode |= WL1273_IS2_WIDTH_50;

		break;

	case 30:

		mode |= WL1273_IS2_WIDTH_60;

		break;

	case 32:

		mode |= WL1273_IS2_WIDTH_64;

		break;

	case 40:

		mode |= WL1273_IS2_WIDTH_80;

		break;

	case 48:

		mode |= WL1273_IS2_WIDTH_96;

		break;

	case 64:

		mode |= WL1273_IS2_WIDTH_128;

		break;

	default:

		dev_err(dev, "Data width: %d not supported\n", width);

		r = -EINVAL;

		goto out;

	}



	dev_dbg(dev, "WL1273_I2S_DEF_MODE: 0x%04x\n",  WL1273_I2S_DEF_MODE);

	dev_dbg(dev, "core->i2s_mode: 0x%04x\n", core->i2s_mode);

	dev_dbg(dev, "mode: 0x%04x\n", mode);



	if (core->i2s_mode != mode) {

		r = wl1273_fm_write_cmd(core, WL1273_I2S_MODE_CONFIG_SET, mode);

		if (r)

			goto out;



		core->i2s_mode = mode;

		r = wl1273_fm_write_cmd(core, WL1273_AUDIO_ENABLE,

					WL1273_AUDIO_ENABLE_I2S);

		if (r)

			goto out;

	}

out:

	mutex_unlock(&core->lock);



	return r;

}



static int snd_wl1273_fm_set_channel_number(struct wl1273_core *core,

					    int channel_number)

{

	struct i2c_client *client = core->i2c_dev;

	struct device *dev = &client->dev;

	int r = 0;



	dev_dbg(dev, "%s\n", __func__);



	mutex_lock(&core->lock);



	if (core->channel_number == channel_number)

		goto out;



	if (channel_number == 1 && core->mode == WL1273_MODE_RX)

		r = wl1273_fm_write_cmd(core, WL1273_MOST_MODE_SET,

					WL1273_RX_MONO);

	else if (channel_number == 1 && core->mode == WL1273_MODE_TX)

		r = wl1273_fm_write_cmd(core, WL1273_MONO_SET,

					WL1273_TX_MONO);

	else if (channel_number == 2 && core->mode == WL1273_MODE_RX)

		r = wl1273_fm_write_cmd(core, WL1273_MOST_MODE_SET,

					WL1273_RX_STEREO);

	else if (channel_number == 2 && core->mode == WL1273_MODE_TX)

		r = wl1273_fm_write_cmd(core, WL1273_MONO_SET,

					WL1273_TX_STEREO);

	else

		r = -EINVAL;

out:

	mutex_unlock(&core->lock);



	return r;

}



static int snd_wl1273_get_audio_route(struct snd_kcontrol *kcontrol,

				      struct snd_ctl_elem_value *ucontrol)

{

	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);

	struct wl1273_priv *wl1273 = snd_soc_codec_get_drvdata(codec);



	ucontrol->value.integer.value[0] = wl1273->mode;



	return 0;

}



static const char *wl1273_audio_route[] = { "Bt", "FmRx", "FmTx" };



static int snd_wl1273_set_audio_route(struct snd_kcontrol *kcontrol,

				      struct snd_ctl_elem_value *ucontrol)

{

	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);

	struct wl1273_priv *wl1273 = snd_soc_codec_get_drvdata(codec);



	/* Do not allow changes while stream is running */

	if (codec->active)

		return -EPERM;



	if (ucontrol->value.integer.value[0] < 0 ||

	    ucontrol->value.integer.value[0] >=  ARRAY_SIZE(wl1273_audio_route))

		return -EINVAL;



	wl1273->mode = ucontrol->value.integer.value[0];



	return 1;

}



static const struct soc_enum wl1273_enum =

	SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(wl1273_audio_route), wl1273_audio_route);



static int snd_wl1273_fm_audio_get(struct snd_kcontrol *kcontrol,

				   struct snd_ctl_elem_value *ucontrol)

{

	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);

	struct wl1273_priv *wl1273 = snd_soc_codec_get_drvdata(codec);



	dev_dbg(codec->dev, "%s: enter.\n", __func__);



	ucontrol->value.integer.value[0] = wl1273->core->audio_mode;



	return 0;

}



static int snd_wl1273_fm_audio_put(struct snd_kcontrol *kcontrol,

				   struct snd_ctl_elem_value *ucontrol)

{

	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);

	struct wl1273_priv *wl1273 = snd_soc_codec_get_drvdata(codec);

	int val, r = 0;



	dev_dbg(codec->dev, "%s: enter.\n", __func__);



	val = ucontrol->value.integer.value[0];

	if (wl1273->core->audio_mode == val)

		return 0;



	r = wl1273_fm_set_audio(wl1273->core, val);

	if (r < 0)

		return r;



	return 1;

}



static const char *wl1273_audio_strings[] = { "Digital", "Analog" };



static const struct soc_enum wl1273_audio_enum =

	SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(wl1273_audio_strings),

			    wl1273_audio_strings);



static int snd_wl1273_fm_volume_get(struct snd_kcontrol *kcontrol,

				    struct snd_ctl_elem_value *ucontrol)

{

	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);

	struct wl1273_priv *wl1273 = snd_soc_codec_get_drvdata(codec);



	dev_dbg(codec->dev, "%s: enter.\n", __func__);



	ucontrol->value.integer.value[0] = wl1273->core->volume;



	return 0;

}



static int snd_wl1273_fm_volume_put(struct snd_kcontrol *kcontrol,

				    struct snd_ctl_elem_value *ucontrol)

{

	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);

	struct wl1273_priv *wl1273 = snd_soc_codec_get_drvdata(codec);

	int r;



	dev_dbg(codec->dev, "%s: enter.\n", __func__);



	r = wl1273_fm_set_volume(wl1273->core,

				 ucontrol->value.integer.value[0]);

	if (r)

		return r;



	return 1;

}



static const struct snd_kcontrol_new wl1273_controls[] = {

	SOC_ENUM_EXT("Codec Mode", wl1273_enum,

		     snd_wl1273_get_audio_route, snd_wl1273_set_audio_route),

	SOC_ENUM_EXT("Audio Switch", wl1273_audio_enum,

		     snd_wl1273_fm_audio_get,  snd_wl1273_fm_audio_put),

	SOC_SINGLE_EXT("Volume", 0, 0, WL1273_MAX_VOLUME, 0,

		       snd_wl1273_fm_volume_get, snd_wl1273_fm_volume_put),

};



static int wl1273_startup(struct snd_pcm_substream *substream,

			  struct snd_soc_dai *dai)

{

	struct snd_soc_pcm_runtime *rtd = substream->private_data;

	struct snd_soc_codec *codec = rtd->codec;

	struct wl1273_priv *wl1273 = snd_soc_codec_get_drvdata(codec);



	switch (wl1273->mode) {

	case WL1273_MODE_BT:

		snd_pcm_hw_constraint_minmax(substream->runtime,

					     SNDRV_PCM_HW_PARAM_RATE,

					     8000, 8000);

		snd_pcm_hw_constraint_minmax(substream->runtime,

					     SNDRV_PCM_HW_PARAM_CHANNELS, 1, 1);

		break;

	case WL1273_MODE_FM_RX:

		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {

			pr_err("Cannot play in RX mode.\n");

			return -EINVAL;

		}

		break;

	case WL1273_MODE_FM_TX:

		if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {

			pr_err("Cannot capture in TX mode.\n");

			return -EINVAL;

		}

		break;

	default:

		return -EINVAL;

		break;

	}



	return 0;

}



static int wl1273_hw_params(struct snd_pcm_substream *substream,

			    struct snd_pcm_hw_params *params,

			    struct snd_soc_dai *dai)

{

	struct snd_soc_pcm_runtime *rtd = substream->private_data;

	struct wl1273_priv *wl1273 = snd_soc_codec_get_drvdata(rtd->codec);

	struct wl1273_core *core = wl1273->core;

	unsigned int rate, width, r;



	if (params_format(params) != SNDRV_PCM_FORMAT_S16_LE) {

		pr_err("Only SNDRV_PCM_FORMAT_S16_LE supported.\n");

		return -EINVAL;

	}



	rate = params_rate(params);

	width =  hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS)->min;



	if (wl1273->mode == WL1273_MODE_BT) {

		if (rate != 8000) {

			pr_err("Rate %d not supported.\n", params_rate(params));

			return -EINVAL;

		}



		if (params_channels(params) != 1) {

			pr_err("Only mono supported.\n");

			return -EINVAL;

		}



		return 0;

	}



	if (wl1273->mode == WL1273_MODE_FM_TX &&

	    substream->stream == SNDRV_PCM_STREAM_CAPTURE) {

		pr_err("Only playback supported with TX.\n");

		return -EINVAL;

	}



	if (wl1273->mode == WL1273_MODE_FM_RX  &&

	    substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {

		pr_err("Only capture supported with RX.\n");

		return -EINVAL;

	}



	if (wl1273->mode != WL1273_MODE_FM_RX  &&

	    wl1273->mode != WL1273_MODE_FM_TX) {

		pr_err("Unexpected mode: %d.\n", wl1273->mode);

		return -EINVAL;

	}



	r = snd_wl1273_fm_set_i2s_mode(core, rate, width);

	if (r)

		return r;



	wl1273->channels = params_channels(params);

	r = snd_wl1273_fm_set_channel_number(core, wl1273->channels);

	if (r)

		return r;



	return 0;

}



static struct snd_soc_dai_ops wl1273_dai_ops = {

	.startup	= wl1273_startup,

	.hw_params	= wl1273_hw_params,

};



static struct snd_soc_dai_driver wl1273_dai = {

	.name = "wl1273-fm",

	.playback = {

		.stream_name = "Playback",

		.channels_min = 1,

		.channels_max = 2,

		.rates = SNDRV_PCM_RATE_8000_48000,

		.formats = SNDRV_PCM_FMTBIT_S16_LE},

	.capture = {

		.stream_name = "Capture",

		.channels_min = 1,

		.channels_max = 2,

		.rates = SNDRV_PCM_RATE_8000_48000,

		.formats = SNDRV_PCM_FMTBIT_S16_LE},

	.ops = &wl1273_dai_ops,

};



/* Audio interface format for the soc_card driver */

int wl1273_get_format(struct snd_soc_codec *codec, unsigned int *fmt)

{

	struct wl1273_priv *wl1273;



	if (codec == NULL || fmt == NULL)

		return -EINVAL;



	wl1273 = snd_soc_codec_get_drvdata(codec);



	switch (wl1273->mode) {

	case WL1273_MODE_FM_RX:

	case WL1273_MODE_FM_TX:

		*fmt =	SND_SOC_DAIFMT_I2S |

			SND_SOC_DAIFMT_NB_NF |

			SND_SOC_DAIFMT_CBM_CFM;



		break;

	case WL1273_MODE_BT:

		*fmt =	SND_SOC_DAIFMT_DSP_A |

			SND_SOC_DAIFMT_IB_NF |

			SND_SOC_DAIFMT_CBM_CFM;



		break;

	default:

		return -EINVAL;

	}



	return 0;

}

EXPORT_SYMBOL_GPL(wl1273_get_format);



static int wl1273_probe(struct snd_soc_codec *codec)

{

	struct wl1273_core **core = codec->dev->platform_data;

	struct wl1273_priv *wl1273;

	int r;



	dev_dbg(codec->dev, "%s.\n", __func__);



	if (!core) {

		dev_err(codec->dev, "Platform data is missing.\n");

		return -EINVAL;

	}



	wl1273 = kzalloc(sizeof(struct wl1273_priv), GFP_KERNEL);

	if (wl1273 == NULL) {

		dev_err(codec->dev, "Cannot allocate memory.\n");

		return -ENOMEM;

	}



	wl1273->mode = WL1273_MODE_BT;

	wl1273->core = *core;



	snd_soc_codec_set_drvdata(codec, wl1273);

	mutex_init(&codec->mutex);



	r = snd_soc_add_controls(codec, wl1273_controls,

				 ARRAY_SIZE(wl1273_controls));

	if (r)

		kfree(wl1273);



	return r;

}



static int wl1273_remove(struct snd_soc_codec *codec)

{

	struct wl1273_priv *wl1273 = snd_soc_codec_get_drvdata(codec);



	dev_dbg(codec->dev, "%s\n", __func__);

	kfree(wl1273);



	return 0;

}



static struct snd_soc_codec_driver soc_codec_dev_wl1273 = {

	.probe = wl1273_probe,

	.remove = wl1273_remove,

};



static int __devinit wl1273_platform_probe(struct platform_device *pdev)

{

	return snd_soc_register_codec(&pdev->dev, &soc_codec_dev_wl1273,

				      &wl1273_dai, 1);

}



static int __devexit wl1273_platform_remove(struct platform_device *pdev)

{

	snd_soc_unregister_codec(&pdev->dev);

	return 0;

}



MODULE_ALIAS("platform:wl1273-codec");



static struct platform_driver wl1273_platform_driver = {

	.driver		= {

		.name	= "wl1273-codec",

		.owner	= THIS_MODULE,

	},

	.probe		= wl1273_platform_probe,

	.remove		= __devexit_p(wl1273_platform_remove),

};



static int __init wl1273_init(void)

{

	return platform_driver_register(&wl1273_platform_driver);

}

module_init(wl1273_init);



static void __exit wl1273_exit(void)

{

	platform_driver_unregister(&wl1273_platform_driver);

}

module_exit(wl1273_exit);



MODULE_AUTHOR("Matti Aaltonen <matti.j.aaltonen@nokia.com>");

MODULE_DESCRIPTION("ASoC WL1273 codec driver");

MODULE_LICENSE("GPL");

sound/soc/codecs/wl1273.h

0 → 100644
+101 −0
Original line number Original line Diff line number Diff line 
/*

 * sound/soc/codec/wl1273.h

 *

 * ALSA SoC WL1273 codec driver

 *

 * Copyright (C) Nokia Corporation

 * Author: Matti Aaltonen <matti.j.aaltonen@nokia.com>

 *

 * 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.

 *

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

 * 02110-1301 USA

 *

 */



#ifndef __WL1273_CODEC_H__

#define __WL1273_CODEC_H__



/* I2S protocol, left channel first, data width 16 bits */

#define WL1273_PCM_DEF_MODE		0x00



/* Rx */

#define WL1273_AUDIO_ENABLE_I2S		(1 << 0)

#define WL1273_AUDIO_ENABLE_ANALOG	(1 << 1)



/* Tx */

#define WL1273_AUDIO_IO_SET_ANALOG	0

#define WL1273_AUDIO_IO_SET_I2S		1



#define WL1273_POWER_SET_OFF		0

#define WL1273_POWER_SET_FM		(1 << 0)

#define WL1273_POWER_SET_RDS		(1 << 1)

#define WL1273_POWER_SET_RETENTION	(1 << 4)



#define WL1273_PUPD_SET_OFF		0x00

#define WL1273_PUPD_SET_ON		0x01

#define WL1273_PUPD_SET_RETENTION	0x10



/* I2S mode */

#define WL1273_IS2_WIDTH_32	0x0

#define WL1273_IS2_WIDTH_40	0x1

#define WL1273_IS2_WIDTH_22_23	0x2

#define WL1273_IS2_WIDTH_23_22	0x3

#define WL1273_IS2_WIDTH_48	0x4

#define WL1273_IS2_WIDTH_50	0x5

#define WL1273_IS2_WIDTH_60	0x6

#define WL1273_IS2_WIDTH_64	0x7

#define WL1273_IS2_WIDTH_80	0x8

#define WL1273_IS2_WIDTH_96	0x9

#define WL1273_IS2_WIDTH_128	0xa

#define WL1273_IS2_WIDTH	0xf



#define WL1273_IS2_FORMAT_STD	(0x0 << 4)

#define WL1273_IS2_FORMAT_LEFT	(0x1 << 4)

#define WL1273_IS2_FORMAT_RIGHT	(0x2 << 4)

#define WL1273_IS2_FORMAT_USER	(0x3 << 4)



#define WL1273_IS2_MASTER	(0x0 << 6)

#define WL1273_IS2_SLAVEW	(0x1 << 6)



#define WL1273_IS2_TRI_AFTER_SENDING	(0x0 << 7)

#define WL1273_IS2_TRI_ALWAYS_ACTIVE	(0x1 << 7)



#define WL1273_IS2_SDOWS_RR	(0x0 << 8)

#define WL1273_IS2_SDOWS_RF	(0x1 << 8)

#define WL1273_IS2_SDOWS_FR	(0x2 << 8)

#define WL1273_IS2_SDOWS_FF	(0x3 << 8)



#define WL1273_IS2_TRI_OPT	(0x0 << 10)

#define WL1273_IS2_TRI_ALWAYS	(0x1 << 10)



#define WL1273_IS2_RATE_48K	(0x0 << 12)

#define WL1273_IS2_RATE_44_1K	(0x1 << 12)

#define WL1273_IS2_RATE_32K	(0x2 << 12)

#define WL1273_IS2_RATE_22_05K	(0x4 << 12)

#define WL1273_IS2_RATE_16K	(0x5 << 12)

#define WL1273_IS2_RATE_12K	(0x8 << 12)

#define WL1273_IS2_RATE_11_025	(0x9 << 12)

#define WL1273_IS2_RATE_8K	(0xa << 12)

#define WL1273_IS2_RATE		(0xf << 12)



#define WL1273_I2S_DEF_MODE	(WL1273_IS2_WIDTH_32 | \

				 WL1273_IS2_FORMAT_STD | \

				 WL1273_IS2_MASTER | \

				 WL1273_IS2_TRI_AFTER_SENDING | \

				 WL1273_IS2_SDOWS_RR | \

				 WL1273_IS2_TRI_OPT | \

				 WL1273_IS2_RATE_48K)



int wl1273_get_format(struct snd_soc_codec *codec, unsigned int *fmt);



#endif	/* End of __WL1273_CODEC_H__ */

sound/soc/fsl/fsl_dma.c

+51 −16
Original line number Original line Diff line number Diff line
@@ -60,6 +60,7 @@ struct dma_object { 
	struct snd_soc_platform_driver dai;

	struct snd_soc_platform_driver dai;

	dma_addr_t ssi_stx_phys;

	dma_addr_t ssi_stx_phys;

	dma_addr_t ssi_srx_phys;

	dma_addr_t ssi_srx_phys;

	unsigned int ssi_fifo_depth;

	struct ccsr_dma_channel __iomem *channel;

	struct ccsr_dma_channel __iomem *channel;

	unsigned int irq;

	unsigned int irq;

	bool assigned;

	bool assigned;
@@ -99,6 +100,7 @@ struct fsl_dma_private { 
	unsigned int irq;

	unsigned int irq;

	struct snd_pcm_substream *substream;

	struct snd_pcm_substream *substream;

	dma_addr_t ssi_sxx_phys;

	dma_addr_t ssi_sxx_phys;

	unsigned int ssi_fifo_depth;

	dma_addr_t ld_buf_phys;

	dma_addr_t ld_buf_phys;

	unsigned int current_link;

	unsigned int current_link;

	dma_addr_t dma_buf_phys;

	dma_addr_t dma_buf_phys;
@@ -439,6 +441,7 @@ static int fsl_dma_open(struct snd_pcm_substream *substream) 
	else

	else

		dma_private->ssi_sxx_phys = dma->ssi_srx_phys;

		dma_private->ssi_sxx_phys = dma->ssi_srx_phys;





	dma_private->ssi_fifo_depth = dma->ssi_fifo_depth;

	dma_private->dma_channel = dma->channel;

	dma_private->dma_channel = dma->channel;

	dma_private->irq = dma->irq;

	dma_private->irq = dma->irq;

	dma_private->substream = substream;

	dma_private->substream = substream;
@@ -552,11 +555,11 @@ static int fsl_dma_hw_params(struct snd_pcm_substream *substream, 
	struct device *dev = rtd->platform->dev;

	struct device *dev = rtd->platform->dev;





	/* Number of bits per sample */

	/* Number of bits per sample */

	unsigned int sample_size =

	unsigned int sample_bits =

		snd_pcm_format_physical_width(params_format(hw_params));

		snd_pcm_format_physical_width(params_format(hw_params));





	/* Number of bytes per frame */

	/* Number of bytes per frame */

	unsigned int frame_size = 2 * (sample_size / 8);

	unsigned int sample_bytes = sample_bits / 8;





	/* Bus address of SSI STX register */

	/* Bus address of SSI STX register */

	dma_addr_t ssi_sxx_phys = dma_private->ssi_sxx_phys;

	dma_addr_t ssi_sxx_phys = dma_private->ssi_sxx_phys;
@@ -596,7 +599,7 @@ static int fsl_dma_hw_params(struct snd_pcm_substream *substream, 
	 * that offset here.  While we're at it, also tell the DMA controller

	 * that offset here.  While we're at it, also tell the DMA controller

	 * how much data to transfer per sample.

	 * how much data to transfer per sample.

	 */

	 */

	switch (sample_size) {

	switch (sample_bits) {

	case 8:

	case 8:

		mr |= CCSR_DMA_MR_DAHTS_1 | CCSR_DMA_MR_SAHTS_1;

		mr |= CCSR_DMA_MR_DAHTS_1 | CCSR_DMA_MR_SAHTS_1;

		ssi_sxx_phys += 3;

		ssi_sxx_phys += 3;
@@ -610,22 +613,42 @@ static int fsl_dma_hw_params(struct snd_pcm_substream *substream, 
		break;

		break;

	default:

	default:

		/* We should never get here */

		/* We should never get here */

		dev_err(dev, "unsupported sample size %u\n", sample_size);

		dev_err(dev, "unsupported sample size %u\n", sample_bits);

		return -EINVAL;

		return -EINVAL;

	}

	}





	/*

	/*

	 * BWC should always be a multiple of the frame size.  BWC determines

	 * BWC determines how many bytes are sent/received before the DMA

	 * how many bytes are sent/received before the DMA controller checks the

	 * controller checks the SSI to see if it needs to stop. BWC should

	 * SSI to see if it needs to stop.  For playback, the transmit FIFO can

	 * always be a multiple of the frame size, so that we always transmit

	 * hold three frames, so we want to send two frames at a time. For

	 * whole frames.  Each frame occupies two slots in the FIFO.  The

	 * capture, the receive FIFO is triggered when it contains one frame, so

	 * parameter for CCSR_DMA_MR_BWC() is rounded down the next power of two

	 * we want to receive one frame at a time.

	 * (MR[BWC] can only represent even powers of two).

	 *

	 * To simplify the process, we set BWC to the largest value that is

	 * less than or equal to the FIFO watermark.  For playback, this ensures

	 * that we transfer the maximum amount without overrunning the FIFO.

	 * For capture, this ensures that we transfer the maximum amount without

	 * underrunning the FIFO.

	 *

	 * f = SSI FIFO depth

	 * w = SSI watermark value (which equals f - 2)

	 * b = DMA bandwidth count (in bytes)

	 * s = sample size (in bytes, which equals frame_size * 2)

	 *

	 * For playback, we never transmit more than the transmit FIFO

	 * watermark, otherwise we might write more data than the FIFO can hold.

	 * The watermark is equal to the FIFO depth minus two.

	 *

	 * For capture, two equations must hold:

	 *	w > f - (b / s)

	 *	w >= b / s

	 *

	 * So, b > 2 * s, but b must also be <= s * w.  To simplify, we set

	 * b = s * w, which is equal to

	 *      (dma_private->ssi_fifo_depth - 2) * sample_bytes.

	 */

	 */

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)

	mr |= CCSR_DMA_MR_BWC((dma_private->ssi_fifo_depth - 2) * sample_bytes);

		mr |= CCSR_DMA_MR_BWC(2 * frame_size);

	else

		mr |= CCSR_DMA_MR_BWC(frame_size);





	out_be32(&dma_channel->mr, mr);

	out_be32(&dma_channel->mr, mr);
@@ -879,6 +902,7 @@ static int __devinit fsl_soc_dma_probe(struct of_device *of_dev, 
	struct device_node *np = of_dev->dev.of_node;

	struct device_node *np = of_dev->dev.of_node;

	struct device_node *ssi_np;

	struct device_node *ssi_np;

	struct resource res;

	struct resource res;

	const uint32_t *iprop;

	int ret;

	int ret;





	/* Find the SSI node that points to us. */

	/* Find the SSI node that points to us. */
@@ -889,15 +913,17 @@ static int __devinit fsl_soc_dma_probe(struct of_device *of_dev, 
	}

	}





	ret = of_address_to_resource(ssi_np, 0, &res);

	ret = of_address_to_resource(ssi_np, 0, &res);

	of_node_put(ssi_np);

	if (ret) {

	if (ret) {

		dev_err(&of_dev->dev, "could not determine device resources\n");

		dev_err(&of_dev->dev, "could not determine resources for %s\n",

			ssi_np->full_name);

		of_node_put(ssi_np);

		return ret;

		return ret;

	}

	}





	dma = kzalloc(sizeof(*dma) + strlen(np->full_name), GFP_KERNEL);

	dma = kzalloc(sizeof(*dma) + strlen(np->full_name), GFP_KERNEL);

	if (!dma) {

	if (!dma) {

		dev_err(&of_dev->dev, "could not allocate dma object\n");

		dev_err(&of_dev->dev, "could not allocate dma object\n");

		of_node_put(ssi_np);

		return -ENOMEM;

		return -ENOMEM;

	}

	}
@@ -910,6 +936,15 @@ static int __devinit fsl_soc_dma_probe(struct of_device *of_dev, 
	dma->ssi_stx_phys = res.start + offsetof(struct ccsr_ssi, stx0);

	dma->ssi_stx_phys = res.start + offsetof(struct ccsr_ssi, stx0);

	dma->ssi_srx_phys = res.start + offsetof(struct ccsr_ssi, srx0);

	dma->ssi_srx_phys = res.start + offsetof(struct ccsr_ssi, srx0);





	iprop = of_get_property(ssi_np, "fsl,fifo-depth", NULL);

	if (iprop)

		dma->ssi_fifo_depth = *iprop;

	else

                /* Older 8610 DTs didn't have the fifo-depth property */

		dma->ssi_fifo_depth = 8;



	of_node_put(ssi_np);



	ret = snd_soc_register_platform(&of_dev->dev, &dma->dai);

	ret = snd_soc_register_platform(&of_dev->dev, &dma->dai);

	if (ret) {

	if (ret) {

		dev_err(&of_dev->dev, "could not register platform\n");

		dev_err(&of_dev->dev, "could not register platform\n");

sound/soc/fsl/fsl_ssi.c

+22 −3
Original line number Original line Diff line number Diff line
@@ -93,6 +93,7 @@ struct fsl_ssi_private { 
	unsigned int playback;

	unsigned int playback;

	unsigned int capture;

	unsigned int capture;

	int asynchronous;

	int asynchronous;

	unsigned int fifo_depth;

	struct snd_soc_dai_driver cpu_dai_drv;

	struct snd_soc_dai_driver cpu_dai_drv;

	struct device_attribute dev_attr;

	struct device_attribute dev_attr;

	struct platform_device *pdev;

	struct platform_device *pdev;
@@ -337,11 +338,20 @@ static int fsl_ssi_startup(struct snd_pcm_substream *substream, 




		/*

		/*

		 * Set the watermark for transmit FIFI 0 and receive FIFO 0. We

		 * Set the watermark for transmit FIFI 0 and receive FIFO 0. We

		 * don't use FIFO 1.  Since the SSI only supports stereo, the

		 * don't use FIFO 1.  We program the transmit water to signal a

		 * watermark should never be an odd number.

		 * DMA transfer if there are only two (or fewer) elements left

		 * in the FIFO.  Two elements equals one frame (left channel,

		 * right channel).  This value, however, depends on the depth of

		 * the transmit buffer.

		 *

		 * We program the receive FIFO to notify us if at least two

		 * elements (one frame) have been written to the FIFO.  We could

		 * make this value larger (and maybe we should), but this way

		 * data will be written to memory as soon as it's available.

		 */

		 */

		out_be32(&ssi->sfcsr,

		out_be32(&ssi->sfcsr,

			 CCSR_SSI_SFCSR_TFWM0(6) | CCSR_SSI_SFCSR_RFWM0(2));

			CCSR_SSI_SFCSR_TFWM0(ssi_private->fifo_depth - 2) |

			CCSR_SSI_SFCSR_RFWM0(ssi_private->fifo_depth - 2));





		/*

		/*

		 * We keep the SSI disabled because if we enable it, then the

		 * We keep the SSI disabled because if we enable it, then the
@@ -622,6 +632,7 @@ static int __devinit fsl_ssi_probe(struct of_device *of_dev, 
	struct device_attribute *dev_attr = NULL;

	struct device_attribute *dev_attr = NULL;

	struct device_node *np = of_dev->dev.of_node;

	struct device_node *np = of_dev->dev.of_node;

	const char *p, *sprop;

	const char *p, *sprop;

	const uint32_t *iprop;

	struct resource res;

	struct resource res;

	char name[64];

	char name[64];
@@ -678,6 +689,14 @@ static int __devinit fsl_ssi_probe(struct of_device *of_dev, 
	else

	else

		ssi_private->cpu_dai_drv.symmetric_rates = 1;

		ssi_private->cpu_dai_drv.symmetric_rates = 1;





	/* Determine the FIFO depth. */

	iprop = of_get_property(np, "fsl,fifo-depth", NULL);

	if (iprop)

		ssi_private->fifo_depth = *iprop;

	else

                /* Older 8610 DTs didn't have the fifo-depth property */

		ssi_private->fifo_depth = 8;



	/* Initialize the the device_attribute structure */

	/* Initialize the the device_attribute structure */

	dev_attr = &ssi_private->dev_attr;

	dev_attr = &ssi_private->dev_attr;

	dev_attr->attr.name = "statistics";

	dev_attr->attr.name = "statistics";