pxa2xx-ac97.c 7.77 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 * linux/sound/pxa2xx-ac97.c -- AC97 support for the Intel PXA2xx chip.
 *
 * Author:	Nicolas Pitre
 * Created:	Dec 02, 2004
 * Copyright:	MontaVista Software Inc.
 *
 * 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/init.h>
14
#include <linux/io.h>
15 16
#include <linux/module.h>
#include <linux/platform_device.h>
17
#include <linux/dmaengine.h>
18
#include <linux/dma/pxa-dma.h>
19 20 21 22

#include <sound/core.h>
#include <sound/ac97_codec.h>
#include <sound/soc.h>
23
#include <sound/pxa2xx-lib.h>
24
#include <sound/dmaengine_pcm.h>
25

26
#include <mach/hardware.h>
27
#include <mach/regs-ac97.h>
28
#include <mach/audio.h>
29 30 31

static void pxa2xx_ac97_warm_reset(struct snd_ac97 *ac97)
{
32
	pxa2xx_ac97_try_warm_reset();
33

34
	pxa2xx_ac97_finish_reset();
35 36 37 38
}

static void pxa2xx_ac97_cold_reset(struct snd_ac97 *ac97)
{
39
	pxa2xx_ac97_try_cold_reset();
40

41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
	pxa2xx_ac97_finish_reset();
}

static unsigned short pxa2xx_ac97_legacy_read(struct snd_ac97 *ac97,
					      unsigned short reg)
{
	int ret;

	ret = pxa2xx_ac97_read(ac97->num, reg);
	if (ret < 0)
		return 0;
	else
		return (unsigned short)(ret & 0xffff);
}

static void pxa2xx_ac97_legacy_write(struct snd_ac97 *ac97,
				     unsigned short reg, unsigned short val)
{
	int ret;

	ret = pxa2xx_ac97_write(ac97->num, reg, val);
62 63
}

64
static struct snd_ac97_bus_ops pxa2xx_ac97_ops = {
65 66
	.read	= pxa2xx_ac97_legacy_read,
	.write	= pxa2xx_ac97_legacy_write,
67 68 69 70
	.warm_reset	= pxa2xx_ac97_warm_reset,
	.reset	= pxa2xx_ac97_cold_reset,
};

71 72 73 74 75
static struct pxad_param pxa2xx_ac97_pcm_stereo_in_req = {
	.prio = PXAD_PRIO_LOWEST,
	.drcmr = 11,
};

76 77 78 79 80
static struct snd_dmaengine_dai_dma_data pxa2xx_ac97_pcm_stereo_in = {
	.addr		= __PREG(PCDR),
	.addr_width	= DMA_SLAVE_BUSWIDTH_4_BYTES,
	.maxburst	= 32,
	.filter_data	= &pxa2xx_ac97_pcm_stereo_in_req,
81 82
};

83 84 85 86 87
static struct pxad_param pxa2xx_ac97_pcm_stereo_out_req = {
	.prio = PXAD_PRIO_LOWEST,
	.drcmr = 12,
};

88 89 90 91 92
static struct snd_dmaengine_dai_dma_data pxa2xx_ac97_pcm_stereo_out = {
	.addr		= __PREG(PCDR),
	.addr_width	= DMA_SLAVE_BUSWIDTH_4_BYTES,
	.maxburst	= 32,
	.filter_data	= &pxa2xx_ac97_pcm_stereo_out_req,
93 94
};

95 96 97 98
static struct pxad_param pxa2xx_ac97_pcm_aux_mono_out_req = {
	.prio = PXAD_PRIO_LOWEST,
	.drcmr = 10,
};
99 100 101 102 103
static struct snd_dmaengine_dai_dma_data pxa2xx_ac97_pcm_aux_mono_out = {
	.addr		= __PREG(MODR),
	.addr_width	= DMA_SLAVE_BUSWIDTH_2_BYTES,
	.maxburst	= 16,
	.filter_data	= &pxa2xx_ac97_pcm_aux_mono_out_req,
104 105
};

106 107 108 109
static struct pxad_param pxa2xx_ac97_pcm_aux_mono_in_req = {
	.prio = PXAD_PRIO_LOWEST,
	.drcmr = 9,
};
110 111 112 113 114
static struct snd_dmaengine_dai_dma_data pxa2xx_ac97_pcm_aux_mono_in = {
	.addr		= __PREG(MODR),
	.addr_width	= DMA_SLAVE_BUSWIDTH_2_BYTES,
	.maxburst	= 16,
	.filter_data	= &pxa2xx_ac97_pcm_aux_mono_in_req,
115 116
};

117 118 119 120
static struct pxad_param pxa2xx_ac97_pcm_aux_mic_mono_req = {
	.prio = PXAD_PRIO_LOWEST,
	.drcmr = 8,
};
121 122 123 124 125
static struct snd_dmaengine_dai_dma_data pxa2xx_ac97_pcm_mic_mono_in = {
	.addr		= __PREG(MCDR),
	.addr_width	= DMA_SLAVE_BUSWIDTH_2_BYTES,
	.maxburst	= 16,
	.filter_data	= &pxa2xx_ac97_pcm_aux_mic_mono_req,
126 127
};

128 129
static int pxa2xx_ac97_hifi_startup(struct snd_pcm_substream *substream,
				    struct snd_soc_dai *cpu_dai)
130
{
131
	struct snd_dmaengine_dai_dma_data *dma_data;
132 133

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
134
		dma_data = &pxa2xx_ac97_pcm_stereo_out;
135
	else
136 137 138
		dma_data = &pxa2xx_ac97_pcm_stereo_in;

	snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data);
139 140 141 142

	return 0;
}

143 144
static int pxa2xx_ac97_aux_startup(struct snd_pcm_substream *substream,
				   struct snd_soc_dai *cpu_dai)
145
{
146
	struct snd_dmaengine_dai_dma_data *dma_data;
147 148

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
149
		dma_data = &pxa2xx_ac97_pcm_aux_mono_out;
150
	else
151 152 153
		dma_data = &pxa2xx_ac97_pcm_aux_mono_in;

	snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data);
154 155 156 157

	return 0;
}

158 159
static int pxa2xx_ac97_mic_startup(struct snd_pcm_substream *substream,
				   struct snd_soc_dai *cpu_dai)
160 161 162
{
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
		return -ENODEV;
163 164
	snd_soc_dai_set_dma_data(cpu_dai, substream,
				 &pxa2xx_ac97_pcm_mic_mono_in);
165 166 167 168

	return 0;
}

169 170 171 172
#define PXA2XX_AC97_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
		SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 | SNDRV_PCM_RATE_44100 | \
		SNDRV_PCM_RATE_48000)

173
static const struct snd_soc_dai_ops pxa_ac97_hifi_dai_ops = {
174
	.startup	= pxa2xx_ac97_hifi_startup,
175 176
};

177
static const struct snd_soc_dai_ops pxa_ac97_aux_dai_ops = {
178
	.startup	= pxa2xx_ac97_aux_startup,
179 180
};

181
static const struct snd_soc_dai_ops pxa_ac97_mic_dai_ops = {
182
	.startup	= pxa2xx_ac97_mic_startup,
183 184
};

185 186 187 188
/*
 * There is only 1 physical AC97 interface for pxa2xx, but it
 * has extra fifo's that can be used for aux DACs and ADCs.
 */
189
static struct snd_soc_dai_driver pxa_ac97_dai_driver[] = {
190 191
{
	.name = "pxa2xx-ac97",
192
	.bus_control = true,
193 194 195
	.playback = {
		.stream_name = "AC97 Playback",
		.channels_min = 2,
196 197 198
		.channels_max = 2,
		.rates = PXA2XX_AC97_RATES,
		.formats = SNDRV_PCM_FMTBIT_S16_LE,},
199 200 201
	.capture = {
		.stream_name = "AC97 Capture",
		.channels_min = 2,
202 203 204
		.channels_max = 2,
		.rates = PXA2XX_AC97_RATES,
		.formats = SNDRV_PCM_FMTBIT_S16_LE,},
205
	.ops = &pxa_ac97_hifi_dai_ops,
206 207 208
},
{
	.name = "pxa2xx-ac97-aux",
209
	.bus_control = true,
210 211 212
	.playback = {
		.stream_name = "AC97 Aux Playback",
		.channels_min = 1,
213 214 215
		.channels_max = 1,
		.rates = PXA2XX_AC97_RATES,
		.formats = SNDRV_PCM_FMTBIT_S16_LE,},
216 217 218
	.capture = {
		.stream_name = "AC97 Aux Capture",
		.channels_min = 1,
219 220 221
		.channels_max = 1,
		.rates = PXA2XX_AC97_RATES,
		.formats = SNDRV_PCM_FMTBIT_S16_LE,},
222
	.ops = &pxa_ac97_aux_dai_ops,
223 224 225
},
{
	.name = "pxa2xx-ac97-mic",
226
	.bus_control = true,
227 228 229
	.capture = {
		.stream_name = "AC97 Mic Capture",
		.channels_min = 1,
230 231 232
		.channels_max = 1,
		.rates = PXA2XX_AC97_RATES,
		.formats = SNDRV_PCM_FMTBIT_S16_LE,},
233
	.ops = &pxa_ac97_mic_dai_ops,
234
},
235 236
};

237 238 239 240
static const struct snd_soc_component_driver pxa_ac97_component = {
	.name		= "pxa-ac97",
};

241 242 243 244 245 246 247 248 249 250 251
#ifdef CONFIG_OF
static const struct of_device_id pxa2xx_ac97_dt_ids[] = {
	{ .compatible = "marvell,pxa250-ac97", },
	{ .compatible = "marvell,pxa270-ac97", },
	{ .compatible = "marvell,pxa300-ac97", },
	{ }
};
MODULE_DEVICE_TABLE(of, pxa2xx_ac97_dt_ids);

#endif

252
static int pxa2xx_ac97_dev_probe(struct platform_device *pdev)
Mark Brown's avatar
Mark Brown committed
253
{
254 255
	int ret;

256
	if (pdev->id != -1) {
257 258 259 260
		dev_err(&pdev->dev, "PXA2xx has only one AC97 port.\n");
		return -ENXIO;
	}

261 262 263 264 265 266
	ret = pxa2xx_ac97_hw_probe(pdev);
	if (ret) {
		dev_err(&pdev->dev, "PXA2xx AC97 hw probe error (%d)\n", ret);
		return ret;
	}

267 268 269 270
	ret = snd_soc_set_ac97_ops(&pxa2xx_ac97_ops);
	if (ret != 0)
		return ret;

271 272 273 274
	/* Punt most of the init to the SoC probe; we may need the machine
	 * driver to do interesting things with the clocking to get us up
	 * and running.
	 */
275 276
	return snd_soc_register_component(&pdev->dev, &pxa_ac97_component,
					  pxa_ac97_dai_driver, ARRAY_SIZE(pxa_ac97_dai_driver));
Mark Brown's avatar
Mark Brown committed
277
}
278

279
static int pxa2xx_ac97_dev_remove(struct platform_device *pdev)
280
{
281
	snd_soc_unregister_component(&pdev->dev);
282
	snd_soc_set_ac97_ops(NULL);
283
	pxa2xx_ac97_hw_remove(pdev);
284 285 286
	return 0;
}

287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
#ifdef CONFIG_PM_SLEEP
static int pxa2xx_ac97_dev_suspend(struct device *dev)
{
	return pxa2xx_ac97_hw_suspend();
}

static int pxa2xx_ac97_dev_resume(struct device *dev)
{
	return pxa2xx_ac97_hw_resume();
}

static SIMPLE_DEV_PM_OPS(pxa2xx_ac97_pm_ops,
		pxa2xx_ac97_dev_suspend, pxa2xx_ac97_dev_resume);
#endif

302 303
static struct platform_driver pxa2xx_ac97_driver = {
	.probe		= pxa2xx_ac97_dev_probe,
304
	.remove		= pxa2xx_ac97_dev_remove,
305 306
	.driver		= {
		.name	= "pxa2xx-ac97",
307 308 309
#ifdef CONFIG_PM_SLEEP
		.pm	= &pxa2xx_ac97_pm_ops,
#endif
310
		.of_match_table = of_match_ptr(pxa2xx_ac97_dt_ids),
311 312 313
	},
};

314
module_platform_driver(pxa2xx_ac97_driver);
Mark Brown's avatar
Mark Brown committed
315

316 317 318
MODULE_AUTHOR("Nicolas Pitre");
MODULE_DESCRIPTION("AC97 driver for the Intel PXA2xx chip");
MODULE_LICENSE("GPL");
319
MODULE_ALIAS("platform:pxa2xx-ac97");