Root/target/linux/coldfire/patches/009-Add-ALSA-driver-for-MCF5445x.patch

1From d37d2d880efdc0ce515df4155ddafef3835d1b7f Mon Sep 17 00:00:00 2001
2From: Alison Wang <b18965@freescale.com>
3Date: Thu, 4 Aug 2011 09:59:41 +0800
4Subject: [PATCH 09/52] Add ALSA driver for MCF5445x
5
6Add ALSA driver for MCF54451 and MCF54455.
7
8Signed-off-by: Alison Wang <b18965@freescale.com>
9---
10 sound/Kconfig | 6 +-
11 sound/Makefile | 1 +
12 sound/coldfire/Kconfig | 14 +
13 sound/coldfire/Makefile | 6 +
14 sound/coldfire/coldfire-codec-spi.c | 93 ++
15 sound/coldfire/snd-coldfire.c | 1664 +++++++++++++++++++++++++++++++++++
16 sound/coldfire/snd-coldfire.h | 15 +
17 7 files changed, 1795 insertions(+), 4 deletions(-)
18 create mode 100644 sound/coldfire/Kconfig
19 create mode 100644 sound/coldfire/Makefile
20 create mode 100644 sound/coldfire/coldfire-codec-spi.c
21 create mode 100644 sound/coldfire/snd-coldfire.c
22 create mode 100644 sound/coldfire/snd-coldfire.h
23
24--- a/sound/Kconfig
25+++ b/sound/Kconfig
26@@ -59,8 +59,6 @@ config SOUND_OSS_CORE_PRECLAIM
27 
28 source "sound/oss/dmasound/Kconfig"
29 
30-if !M68K
31-
32 menuconfig SND
33     tristate "Advanced Linux Sound Architecture"
34     help
35@@ -85,6 +83,8 @@ source "sound/aoa/Kconfig"
36 
37 source "sound/arm/Kconfig"
38 
39+source "sound/coldfire/Kconfig"
40+
41 source "sound/atmel/Kconfig"
42 
43 source "sound/spi/Kconfig"
44@@ -121,8 +121,6 @@ source "sound/oss/Kconfig"
45 
46 endif # SOUND_PRIME
47 
48-endif # !M68K
49-
50 endif # SOUND
51 
52 # AC97_BUS is used from both sound and ucb1400
53--- a/sound/Makefile
54+++ b/sound/Makefile
55@@ -8,6 +8,7 @@ obj-$(CONFIG_DMASOUND) += oss/
56 obj-$(CONFIG_SND) += core/ i2c/ drivers/ isa/ pci/ ppc/ arm/ sh/ synth/ usb/ \
57     sparc/ spi/ parisc/ pcmcia/ mips/ soc/ atmel/
58 obj-$(CONFIG_SND_AOA) += aoa/
59+obj-$(CONFIG_SND_COLDFIRE) += coldfire/
60 
61 # This one must be compilable even if sound is configured out
62 obj-$(CONFIG_AC97_BUS) += ac97_bus.o
63--- /dev/null
64+++ b/sound/coldfire/Kconfig
65@@ -0,0 +1,14 @@
66+
67+menu "ALSA for Coldfire"
68+
69+config SND_COLDFIRE
70+ bool "Coldfire sound devices"
71+ depends on SND
72+ select SND_PCM
73+ select SSIAUDIO_USE_EDMA
74+ default y
75+ help
76+ Support for sound devices specific to Coldfire architectures.
77+
78+endmenu
79+
80--- /dev/null
81+++ b/sound/coldfire/Makefile
82@@ -0,0 +1,6 @@
83+#
84+# Makefile for Coldfire ALSA
85+#
86+
87+obj-y += snd-coldfire.o coldfire-codec-spi.o
88+
89--- /dev/null
90+++ b/sound/coldfire/coldfire-codec-spi.c
91@@ -0,0 +1,93 @@
92+/*
93+ * linux/sound/coldfire/coldfire-codec-spi.c
94+ *
95+ * Copyright (C) 2008-2011 Freescale Semiconductor, Inc. All Rights Reserved.
96+ * Author: Kurt Mahan <kmahan@freescale.com>
97+ *
98+ * Simple SPI interface for the CODEC.
99+ *
100+ * This is free software; you can redistribute it and/or modify
101+ * it under the terms of the GNU General Public License as published by
102+ * the Free Software Foundation; either version 2 of the License, or
103+ * (at your option) any later version.
104+ */
105+
106+#include <linux/device.h>
107+#include <linux/init.h>
108+#include <linux/spi/spi.h>
109+#include <linux/kernel.h>
110+#include <asm/mcfsim.h>
111+#include <asm/coldfire.h>
112+#include <linux/delay.h>
113+
114+#define MCF_CODEC_SPI_DRIVER_NAME "mcf_codec_spi"
115+
116+static struct spi_device *mcf_codec_spi;
117+
118+/*
119+ * Write CODEC register via SPI
120+ */
121+int mcf_codec_spi_write(u8 addr, u16 data)
122+{
123+ u16 spi_word;
124+
125+ if (mcf_codec_spi == NULL)
126+ return -ENODEV;
127+
128+ spi_word = ((addr & 0x7F)<<9)|(data & 0x1FF);
129+ return spi_write(mcf_codec_spi, (const u8 *)&spi_word,
130+ sizeof(spi_word));
131+}
132+EXPORT_SYMBOL(mcf_codec_spi_write);
133+
134+static int __devinit mcf_codec_spi_probe(struct spi_device *spi)
135+{
136+ spi->dev.power.power_state = PMSG_ON;
137+ mcf_codec_spi = spi;
138+
139+ return 0;
140+}
141+
142+static int __devexit mcf_codec_spi_remove(struct spi_device *spi)
143+{
144+ return 0;
145+}
146+
147+static int mcf_codec_spi_suspend(struct spi_device *spi, pm_message_t message)
148+{
149+ return 0;
150+}
151+
152+static int mcf_codec_spi_resume(struct spi_device *spi)
153+{
154+ return 0;
155+}
156+
157+static struct spi_driver mcf_codec_spi_driver = {
158+ .driver = {
159+ .name = MCF_CODEC_SPI_DRIVER_NAME,
160+ .bus = &spi_bus_type,
161+ .owner = THIS_MODULE,
162+ },
163+ .probe = mcf_codec_spi_probe,
164+ .remove = __devexit_p(mcf_codec_spi_remove),
165+ .suspend = mcf_codec_spi_suspend,
166+ .resume = mcf_codec_spi_resume,
167+};
168+
169+static int __init mcf_codec_spi_init(void)
170+{
171+ return spi_register_driver(&mcf_codec_spi_driver);
172+}
173+module_init(mcf_codec_spi_init);
174+
175+static void __exit mcf_codec_spi_exit(void)
176+{
177+ spi_unregister_driver(&mcf_codec_spi_driver);
178+}
179+module_exit(mcf_codec_spi_exit);
180+
181+
182+MODULE_DESCRIPTION("Coldfire Codec SPI driver");
183+MODULE_AUTHOR("Kurt Mahan, Freescale Semiconductor, Inc.");
184+MODULE_LICENSE("GPL");
185--- /dev/null
186+++ b/sound/coldfire/snd-coldfire.c
187@@ -0,0 +1,1664 @@
188+/*
189+ * linux/sound/coldfire/snd-coldfire.c
190+ *
191+ * Copyright (C) 2008-2011 Freescale Semiconductor, Inc. All Rights Reserved.
192+ * Author: York Sun <r58495@freescale.com>
193+ * Alison Wang <b18965@freescale.com>
194+ *
195+ * Coldfire ALSA driver based on SSI and TLV320A
196+ *
197+ * This is free software; you can redistribute it and/or modify
198+ * it under the terms of the GNU General Public License as published by
199+ * the Free Software Foundation; either version 2 of the License, or
200+ * (at your option) any later version.
201+ *
202+ ***************************************************************************
203+ *
204+ * NOTE: This driver was tested on MCF5445x, MCF5301x, MCF5227x, MCF532x and
205+ * MCF537x platforms.
206+ * */
207+
208+#include <linux/module.h>
209+#include <linux/moduleparam.h>
210+#include <linux/platform_device.h>
211+#include <linux/init.h>
212+#include <linux/device.h>
213+#include <linux/slab.h>
214+#include <linux/dma-mapping.h>
215+#include <linux/ioctl.h>
216+#include <linux/soundcard.h>
217+#include <linux/spi/spi.h>
218+
219+#include <sound/core.h>
220+#include <sound/pcm.h>
221+#include <sound/pcm_params.h>
222+#include <sound/control.h>
223+#include <linux/fs.h>
224+#include <linux/delay.h>
225+
226+#include <asm/mcfsim.h>
227+#include <asm/coldfire.h>
228+#include <asm/mcf_edma.h>
229+#include "snd-coldfire.h"
230+
231+#if defined(CONFIG_M5445X)
232+#include <asm/mcf5445x_ssi.h>
233+#endif
234+
235+#define CF_ALSA_DEBUG 0
236+#if CF_ALSA_DEBUG
237+#define DBG(fmt, args...) printk(KERN_INFO "[%s] " fmt , \
238+ __func__, ## args)
239+#else
240+#define DBG(fmt, args...) do {} while (0)
241+#endif
242+
243+#define SOUND_CARD_NAME "Coldfire ALSA"
244+#define MAX_BUFFER_SIZE (32*1024)
245+
246+/* eDMA channel for SSI channel 0,1 TX,RX */
247+#define DMA_TX_TCD0 MCF_EDMA_CHAN_TIMER2
248+#define DMA_TX_TCD1 MCF_EDMA_CHAN_TIMER3
249+#define DMA_RX_TCD0 MCF_EDMA_CHAN_TIMER0
250+#define DMA_RX_TCD1 MCF_EDMA_CHAN_TIMER1
251+
252+#define CODEC_LEFT_IN_REG (0x00)
253+#define CODEC_RIGHT_IN_REG (0x01)
254+#define CODEC_LEFT_HP_VOL_REG (0x02)
255+#define CODEC_RIGHT_HP_VOL_REG (0x03)
256+#define CODEC_ANALOG_APATH_REG (0x04)
257+#define CODEC_DIGITAL_APATH_REG (0x05)
258+#define CODEC_POWER_DOWN_REG (0x06)
259+#define CODEC_DIGITAL_IF_FMT_REG (0x07)
260+#define CODEC_SAMPLE_RATE_REG (0x08)
261+#define CODEC_DIGITAL_IF_ACT_REG (0x09)
262+#define CODEC_RESET_REG (0x0f)
263+
264+#define TLV320AIC23_CODEC_SAMPLE_RATE_REG (0x08)
265+#define TLV320AIC23_CODEC_SAMPLERATE_REG_8KHZ (0x0C)
266+#define TLV320AIC23_CODEC_SAMPLERATE_REG_11KHZ (0x0C)
267+#define TLV320AIC23_CODEC_SAMPLERATE_REG_16KHZ (0x58)
268+#define TLV320AIC23_CODEC_SAMPLERATE_REG_22KHZ (0x62)
269+#define TLV320AIC23_CODEC_SAMPLERATE_REG_44KHZ (0x22)
270+#define TLV320AIC23_CODEC_SAMPLERATE_REG_48KHZ (0x00)
271+
272+#define MCF_SSI_AUDIO_IRQ_LEVEL (5)
273+#define TLV320A_VOL_MAX 0x07F
274+#define TLV320A_VOL_MIN 0x030
275+#define TLV320A_VOL_INIT 0x065
276+#define TLV320A_LINEIN_MAX 0x1F
277+#define TLV320A_LINEIN_INIT 0x17
278+#define TLV320A_ANALOGPATH_INIT 0x11
279+
280+/* Codec settings */
281+#define MCF_SSI_AUDIO_MCLK_1 (12288000U) /*Hz*/
282+#define MCF_SSI_AUDIO_MCLK_2 (16934400U) /*Hz*/
283+#define MCF_SSI_AUDIO_MCLK_3 (14112000U) /*Hz*/
284+#define MCF_SSI_AUDIO_MCLK_4 (18432000U) /*Hz*/
285+
286+#define MCF_SSI_AUDIO_SSDIV_VALUE_1 \
287+ ((((u32)MCF_CLK*2)/MCF_SSI_AUDIO_MCLK_1)+ \
288+ (((((u32)MCF_CLK*2*10)/MCF_SSI_AUDIO_MCLK_1)%10) > 5))
289+
290+#define MCF_SSI_AUDIO_SSDIV_VALUE_2 \
291+ ((((u32)MCF_CLK*2)/MCF_SSI_AUDIO_MCLK_2)+ \
292+ (((((u32)MCF_CLK*2*10)/MCF_SSI_AUDIO_MCLK_2)%10) > 5))
293+
294+#define MCF_SSI_AUDIO_SSDIV_VALUE_3 \
295+ ((((u32)MCF_CLK*2)/MCF_SSI_AUDIO_MCLK_3)+ \
296+ (((((u32)MCF_CLK*2*10)/MCF_SSI_AUDIO_MCLK_3)%10) > 5))
297+
298+#define MCF_SSI_AUDIO_SSDIV_VALUE_4 \
299+ ((((u32)MCF_CLK*2)/MCF_SSI_AUDIO_MCLK_4)+ \
300+ (((((u32)MCF_CLK*2*10)/MCF_SSI_AUDIO_MCLK_4)%10) > 5))
301+
302+#define SNDRV_COLDFIRE_PCM_PLAYBACK_FORMATS SNDRV_PCM_FMTBIT_S16_BE
303+#define SNDRV_COLDFIRE_PCM_CAPTURE_FORMATS SNDRV_PCM_FMTBIT_S16_BE
304+
305+#define RXFWM 2
306+#define TXFWM 2
307+#define HW_PERIODS_BYTES_MIN 4096
308+#define HW_PERIODS_BYTES_STEP 4096
309+
310+#define INPUT_MICROPHONE 0
311+#define INPUT_LINEIN 1
312+#define NUM_TCDS 4
313+
314+static char *id;
315+static struct platform_device *device;
316+static int g_tx_dmaing;
317+static int g_rx_dmaing;
318+static unsigned char g_mastervol, g_lineinvol, g_analogpath;
319+
320+/** Use 4 TCDs for scatter/gather address
321+ * to setup dma chain, one TCD per period
322+ * so that we don't need change them on the fly
323+ */
324+
325+/**
326+ * Link Descriptor
327+ *
328+ * must be aligned on a 32-byte boundary.
329+ */
330+struct dma_tcd {
331+ __be32 saddr; /* source address */
332+ __be16 attr; /* transfer attribute */
333+ __be16 soffset; /* source offset */
334+ __be32 nbytes; /* minor byte count */
335+ __be32 slast; /* last source address adjust */
336+ __be32 daddr; /* dest address */
337+ __be16 citer; /* current minor looplink, major count */
338+ __be16 doffset; /* dest offset */
339+ __be32 dlast_sga; /* last dest addr adjust, scatter/gather addr*/
340+ __be16 biter; /* begging minor looklink, major count */
341+ __be16 csr; /* control and status */
342+} __packed;
343+
344+/** dma_private: p-substream DMA data
345+ *
346+ * The tcd[] array is first because it needs to be aligned on a 32-byte
347+ * boundary, so putting it first will ensure alignment without padding the
348+ * structure.
349+ *
350+ * @tcd[]: array of TCDs
351+ */
352+struct dma_private {
353+ struct dma_tcd tcd0[NUM_TCDS];
354+ struct dma_tcd tcd1[NUM_TCDS];
355+ dma_addr_t tcd_buf_phys; /* physical address of dma_private */
356+ dma_addr_t dma_buf_phys;
357+ dma_addr_t dma_buf_next;
358+ dma_addr_t dma_buf_end;
359+ size_t period_size;
360+ unsigned int num_periods;
361+};
362+
363+struct tlv320a_audio_device {
364+ struct spi_device *spi;
365+ u32 speed;
366+ u32 stereo;
367+ u32 bits;
368+ u32 format;
369+ u8 isopen;
370+ u8 dmaing;
371+ u8 ssi_enabled;
372+ u8 channel;
373+ spinlock_t lock;
374+ u8 *audio_buf;
375+};
376+
377+/* chip specific define */
378+struct chip_spec {
379+ struct snd_card *card;
380+ struct snd_pcm *pcm;
381+ struct tlv320a_audio_device *audio_device;
382+ u32 offset;
383+ void *mixer_data;
384+};
385+
386+/* hardware definition */
387+static struct snd_pcm_hardware snd_coldfire_playback_hw = {
388+ .info = (SNDRV_PCM_INFO_INTERLEAVED |
389+#if defined(CONFIG_MMU)
390+ SNDRV_PCM_INFO_MMAP |
391+ SNDRV_PCM_INFO_MMAP_VALID|
392+#endif
393+ SNDRV_PCM_INFO_BLOCK_TRANSFER),
394+ .formats = SNDRV_COLDFIRE_PCM_PLAYBACK_FORMATS,
395+ .rates = SNDRV_PCM_RATE_8000_48000,
396+ .rate_min = 8000,
397+ .rate_max = 48000,
398+ .channels_min = 1,
399+ .channels_max = 2,
400+ .buffer_bytes_max = MAX_BUFFER_SIZE,
401+ .period_bytes_min = HW_PERIODS_BYTES_MIN,
402+ .period_bytes_max = MAX_BUFFER_SIZE/NUM_TCDS,
403+ .periods_min = NUM_TCDS,
404+ .periods_max = NUM_TCDS,
405+ .fifo_size = 0,
406+};
407+
408+/* hardware definition */
409+static struct snd_pcm_hardware snd_coldfire_capture_hw = {
410+ .info = (SNDRV_PCM_INFO_INTERLEAVED |
411+#if defined(CONFIG_MMU)
412+ SNDRV_PCM_INFO_MMAP |
413+ SNDRV_PCM_INFO_MMAP_VALID|
414+#endif
415+ SNDRV_PCM_INFO_BLOCK_TRANSFER),
416+ .formats = SNDRV_COLDFIRE_PCM_CAPTURE_FORMATS,
417+ .rates = SNDRV_PCM_RATE_8000_48000,
418+ .rate_min = 8000,
419+ .rate_max = 48000,
420+ .channels_min = 1,
421+ .channels_max = 2,
422+ .buffer_bytes_max = MAX_BUFFER_SIZE,
423+ .period_bytes_min = HW_PERIODS_BYTES_MIN,
424+ .period_bytes_max = MAX_BUFFER_SIZE/NUM_TCDS,
425+ .periods_min = NUM_TCDS,
426+ .periods_max = NUM_TCDS,
427+ .fifo_size = 0,
428+};
429+
430+static unsigned int rates[] = {8000, 11025, 16000, 22000,
431+ 22050, 44000, 44100, 48000};
432+
433+/* hw constraints */
434+static struct snd_pcm_hw_constraint_list constraints_rates = {
435+ .count = ARRAY_SIZE(rates),
436+ .list = rates,
437+ .mask = 0,
438+};
439+
440+static inline void ssi_audio_dma_playback_start(void)
441+{
442+ g_tx_dmaing = 1;
443+ mcf_edma_start_transfer(DMA_TX_TCD0);
444+ mcf_edma_start_transfer(DMA_TX_TCD1);
445+}
446+
447+static inline void ssi_audio_dma_capture_start(void)
448+{
449+ g_rx_dmaing = 1;
450+ mcf_edma_start_transfer(DMA_RX_TCD0);
451+ mcf_edma_start_transfer(DMA_RX_TCD1);
452+}
453+
454+static inline void ssi_audio_dma_playback_stop(void)
455+{
456+ g_tx_dmaing = 0;
457+ mcf_edma_stop_transfer(DMA_TX_TCD0);
458+ mcf_edma_stop_transfer(DMA_TX_TCD1);
459+}
460+
461+inline void ssi_audio_dma_capture_stop(void)
462+{
463+ g_rx_dmaing = 0;
464+ mcf_edma_stop_transfer(DMA_RX_TCD0);
465+ mcf_edma_stop_transfer(DMA_RX_TCD1);
466+}
467+
468+/**
469+ * fill_tcd_params - Fill transfer control descriptor (TCD)
470+ * @base: base address of TCD
471+ * @source: source address
472+ * @dest: destination address
473+ * @attr: attributes
474+ * @soff: source offset
475+ * @nbytes: number of bytes to be transfered in minor loop
476+ * @slast: last source address adjustment
477+ * @citer: major loop count
478+ * @biter: beginning minor loop count
479+ * @doff: destination offset
480+ * @dlast_sga: last destination address adjustment
481+ * @major_int: generate interrupt after each major loop
482+ * @disable_req: disable DMA request after major loop
483+ * @enable_sg: enable scatter/gather address
484+ */
485+void fill_tcd_params(u32 base, u32 source, u32 dest,
486+ u32 attr, u32 soff, u32 nbytes, u32 slast,
487+ u32 citer, u32 biter, u32 doff, u32 dlast_sga,
488+ int major_int, int disable_req, int enable_sg)
489+{
490+ struct dma_tcd *tcd = (struct dma_tcd *) base;
491+
492+ tcd->saddr = source;
493+ tcd->attr = attr;
494+ tcd->soffset = soff;
495+ tcd->nbytes = nbytes;
496+ tcd->slast = slast;
497+ tcd->daddr = dest;
498+ tcd->citer = citer & 0x7fff;
499+ tcd->doffset = doff;
500+ tcd->dlast_sga = dlast_sga;
501+ tcd->biter = biter & 0x7fff;
502+ tcd->csr = ((major_int) ? 0x2 : 0) |
503+ ((disable_req) ? 0x8 : 0) |
504+ ((enable_sg) ? 0x10 : 0);
505+}
506+
507+static int
508+ssi_audio_dma_playback_config(struct snd_pcm_substream *substream)
509+{
510+ struct snd_pcm_runtime *runtime = substream->runtime;
511+ struct dma_private *dma_private = runtime->private_data;
512+ u32 size = frames_to_bytes(runtime, runtime->period_size);
513+ u32 offset, soffset, daddr0, daddr1, attr, sga0, sga1;
514+ u32 i, nbyte, major_loops;
515+
516+ if ((runtime->channels < 1) || (runtime->channels > 2)) {
517+ printk(KERN_ERR "Error on channels = %d\n", runtime->channels);
518+ return -EINVAL;
519+ }
520+
521+ dma_private->dma_buf_phys = runtime->dma_addr;
522+ dma_private->dma_buf_next = dma_private->dma_buf_phys;
523+ dma_private->dma_buf_end = dma_private->dma_buf_phys +
524+ runtime->periods * size;
525+
526+ if (runtime->format == SNDRV_PCM_FORMAT_S16_BE) {
527+ nbyte = 2 * TXFWM;
528+ soffset = 2 * runtime->channels;
529+ daddr0 = (u32)&MCF_SSI_TX0 + 2;
530+ daddr1 = (u32)&MCF_SSI_TX1 + 2;
531+ attr = MCF_EDMA_TCD_ATTR_SSIZE_16BIT |
532+ MCF_EDMA_TCD_ATTR_DSIZE_16BIT;
533+ } else {
534+ printk(KERN_ERR "Not supported PCM format %x\n",
535+ runtime->format);
536+ return -EINVAL;
537+ }
538+
539+ major_loops = size/nbyte/runtime->channels;
540+ sga0 = (u32)dma_private->tcd_buf_phys;
541+ sga1 = (u32)dma_private->tcd_buf_phys +
542+ 4 * sizeof(struct dma_tcd);
543+
544+#if defined(CONFIG_M5301x) || defined(CONFIG_M5445X)
545+ MCF_EDMA_TCD10_CSR = 0;
546+ MCF_EDMA_TCD11_CSR = 0;
547+#else
548+ MCF_EDMA_TCD11_CSR = 0;
549+ MCF_EDMA_TCD12_CSR = 0;
550+#endif
551+ offset = (runtime->channels - 1) * 2;
552+ mcf_edma_set_tcd_params(DMA_TX_TCD0,
553+ (u32)dma_private->dma_buf_next,
554+ daddr0,
555+ attr,
556+ soffset,
557+ nbyte,
558+ 0, /* slast */
559+ major_loops, /* citer */
560+ major_loops, /* biter */
561+ 0, /* dest offset */
562+ sga0,
563+ 1, /* major_int */
564+ 0); /* enable dma request after */
565+
566+ mcf_edma_set_tcd_params(DMA_TX_TCD1,
567+ (u32)dma_private->dma_buf_next + offset,
568+ daddr1,
569+ attr,
570+ soffset,
571+ nbyte,
572+ 0, /* slast */
573+ major_loops, /* citer */
574+ major_loops, /* biter */
575+ 0, /* dest offset */
576+ sga1,
577+ 0, /* major_int */
578+ 0); /* enable dma request after */
579+
580+ while (!(MCF_EDMA_TCD_CSR(DMA_TX_TCD0) & MCF_EDMA_TCD_CSR_E_SG))
581+ MCF_EDMA_TCD_CSR(DMA_TX_TCD0) |= MCF_EDMA_TCD_CSR_E_SG;
582+ while (!(MCF_EDMA_TCD_CSR(DMA_TX_TCD1) & MCF_EDMA_TCD_CSR_E_SG))
583+ MCF_EDMA_TCD_CSR(DMA_TX_TCD1) |= MCF_EDMA_TCD_CSR_E_SG;
584+
585+ for (i = 0; i < NUM_TCDS; i++) {
586+ dma_private->dma_buf_next += size;
587+ if (dma_private->dma_buf_next >= dma_private->dma_buf_end)
588+ dma_private->dma_buf_next = dma_private->dma_buf_phys;
589+ sga0 = (u32)dma_private->tcd_buf_phys +
590+ ((i+1)%NUM_TCDS) * sizeof(struct dma_tcd);
591+ sga1 = (u32)dma_private->tcd_buf_phys +
592+ ((i+1)%NUM_TCDS + 4) * sizeof(struct dma_tcd);
593+ DBG("sga0 = 0x%x, sga1 = 0x%x.\n", sga0, sga1);
594+ fill_tcd_params((u32)&dma_private->tcd0[i],
595+ (u32)dma_private->dma_buf_next,
596+ daddr0,
597+ attr,
598+ soffset,
599+ nbyte,
600+ 0, /* slast */
601+ major_loops, /* citer */
602+ major_loops, /* biter */
603+ 0, /* dest offset */
604+ sga0,
605+ 1, /* major_int */
606+ 0, /* enable dma request after */
607+ 1); /* enable scatter/gather */
608+
609+ fill_tcd_params((u32)&dma_private->tcd1[i],
610+ (u32)dma_private->dma_buf_next + offset,
611+ daddr1,
612+ attr,
613+ soffset,
614+ nbyte,
615+ 0, /* slast */
616+ major_loops, /* citer */
617+ major_loops, /* biter */
618+ 0, /* dest offset */
619+ sga1,
620+ 0, /* major_int */
621+ 0, /* enable dma request after */
622+ 1); /* enable scatter/gather */
623+ }
624+
625+ return 0;
626+}
627+
628+static int
629+ssi_audio_dma_capture_config(struct snd_pcm_substream *substream)
630+{
631+ struct snd_pcm_runtime *runtime = substream->runtime;
632+ struct dma_private *dma_private = runtime->private_data;
633+ u32 size = frames_to_bytes(runtime, runtime->period_size);
634+ u32 offset, saddr0, saddr1, doffset, attr, sga0, sga1;
635+ int i, nbyte, major_loops;
636+
637+ if ((runtime->channels < 1) || (runtime->channels > 2)) {
638+ printk(KERN_ERR "Error on channels = %d\n", runtime->channels);
639+ return -EINVAL;
640+ }
641+
642+ dma_private->dma_buf_phys = runtime->dma_addr;
643+ dma_private->dma_buf_next = dma_private->dma_buf_phys;
644+ dma_private->dma_buf_end = dma_private->dma_buf_phys +
645+ runtime->periods * size;
646+
647+ switch (runtime->format) {
648+ case SNDRV_PCM_FORMAT_S16_BE:
649+ saddr0 = (u32)&MCF_SSI_RX0 + 2;
650+ saddr1 = (u32)&MCF_SSI_RX1 + 2;
651+ nbyte = 2 * RXFWM;
652+ doffset = 2 * runtime->channels;
653+ attr = MCF_EDMA_TCD_ATTR_SSIZE_16BIT |
654+ MCF_EDMA_TCD_ATTR_DSIZE_16BIT;
655+ break;
656+ default:
657+ printk(KERN_ERR "Not supported PCM format %x\n",
658+ runtime->format);
659+ return -EINVAL;
660+ }
661+
662+ major_loops = size/nbyte/runtime->channels;
663+ sga0 = (u32)dma_private->tcd_buf_phys;
664+ sga1 = (u32)dma_private->tcd_buf_phys +
665+ 4 * sizeof(struct dma_tcd);
666+
667+#if defined(CONFIG_M5301x) || defined(CONFIG_M5445X)
668+ MCF_EDMA_TCD8_CSR = 0;
669+ MCF_EDMA_TCD9_CSR = 0;
670+#else
671+ MCF_EDMA_TCD9_CSR = 0;
672+ MCF_EDMA_TCD10_CSR = 0;
673+#endif
674+ offset = (runtime->channels - 1) * 2;
675+ mcf_edma_set_tcd_params(DMA_RX_TCD0,
676+ saddr0,
677+ (u32)dma_private->dma_buf_next,
678+ attr,
679+ 0, /* source offset */
680+ nbyte,
681+ 0, /* slast */
682+ major_loops, /* citer */
683+ major_loops, /* biter */
684+ doffset,
685+ sga0,
686+ 1, /* major_int */
687+ 0); /* enable dma request after */
688+
689+ mcf_edma_set_tcd_params(DMA_RX_TCD1,
690+ saddr1,
691+ (u32)dma_private->dma_buf_next + offset,
692+ attr,
693+ 0, /* source offset */
694+ nbyte,
695+ 0, /* slast */
696+ major_loops, /* citer */
697+ major_loops, /* biter */
698+ doffset,
699+ sga1,
700+ 0, /* major_int */
701+ 0); /* enable dma request after */
702+
703+ while (!(MCF_EDMA_TCD_CSR(DMA_RX_TCD0) & MCF_EDMA_TCD_CSR_E_SG))
704+ MCF_EDMA_TCD_CSR(DMA_RX_TCD0) |= MCF_EDMA_TCD_CSR_E_SG;
705+ while (!(MCF_EDMA_TCD_CSR(DMA_RX_TCD1) & MCF_EDMA_TCD_CSR_E_SG))
706+ MCF_EDMA_TCD_CSR(DMA_RX_TCD1) |= MCF_EDMA_TCD_CSR_E_SG;
707+
708+ for (i = 0; i < NUM_TCDS; i++) {
709+ dma_private->dma_buf_next += size;
710+ if (dma_private->dma_buf_next >= dma_private->dma_buf_end)
711+ dma_private->dma_buf_next = dma_private->dma_buf_phys;
712+ sga0 = (u32)dma_private->tcd_buf_phys +
713+ ((i+1)%NUM_TCDS) * sizeof(struct dma_tcd);
714+ sga1 = (u32)dma_private->tcd_buf_phys +
715+ ((i+1)%NUM_TCDS + 4) * sizeof(struct dma_tcd);
716+ fill_tcd_params((u32)&dma_private->tcd0[i],
717+ saddr0,
718+ (u32)dma_private->dma_buf_next,
719+ attr,
720+ 0, /* source offset */
721+ nbyte,
722+ 0, /* slast */
723+ major_loops, /* citer */
724+ major_loops, /* biter */
725+ doffset,
726+ sga0,
727+ 1, /* major_int */
728+ 0, /* enable dma request after */
729+ 1); /* enable scatter/gather */
730+ fill_tcd_params((u32)&dma_private->tcd1[i],
731+ saddr1,
732+ (u32)dma_private->dma_buf_next + offset,
733+ attr,
734+ 0, /* source offset */
735+ nbyte,
736+ 0, /* slast */
737+ major_loops, /* citer */
738+ major_loops, /* biter */
739+ doffset,
740+ sga1,
741+ 0, /* major_int */
742+ 0, /* enable dma request after */
743+ 1); /* enable scatter/gather */
744+ }
745+ return 0;
746+}
747+
748+static inline void ssi_audio_enable_ssi_playback(void)
749+{
750+ MCF_SSI_CR |= MCF_SSI_CR_SSI_EN | MCF_SSI_CR_TE;
751+}
752+
753+static inline void ssi_audio_enable_ssi_capture(void)
754+{
755+ MCF_SSI_CR |= MCF_SSI_CR_SSI_EN | MCF_SSI_CR_RE;
756+}
757+
758+static inline void ssi_audio_disable_ssi(void)
759+{
760+ MCF_SSI_CR &= ~(MCF_SSI_CR_TE | MCF_SSI_CR_RE | MCF_SSI_CR_SSI_EN);
761+}
762+
763+static inline void ssi_audio_disable_ssi_playback(void)
764+{
765+ MCF_SSI_CR &= ~MCF_SSI_CR_TE;
766+}
767+
768+static inline void ssi_audio_disable_ssi_capture(void)
769+{
770+ MCF_SSI_CR &= ~MCF_SSI_CR_RE;
771+}
772+
773+static irqreturn_t ssi_audio_dma_playback_handler(int channel, void *dev_id)
774+{
775+ struct snd_pcm_substream *substream;
776+ struct snd_pcm_runtime *runtime;
777+
778+ substream = (struct snd_pcm_substream *)dev_id;
779+ runtime = substream->runtime;
780+
781+ /* inform ALSA middle layer about transfer status */
782+ snd_pcm_period_elapsed(substream);
783+ mcf_edma_confirm_interrupt_handled(DMA_TX_TCD0);
784+ mcf_edma_confirm_interrupt_handled(DMA_TX_TCD1);
785+
786+ return IRQ_HANDLED;
787+}
788+
789+static irqreturn_t ssi_audio_dma_capture_handler(int channel, void *dev_id)
790+{
791+ struct snd_pcm_substream *substream;
792+ struct snd_pcm_runtime *runtime;
793+
794+ substream = (struct snd_pcm_substream *)dev_id;
795+ runtime = substream->runtime;
796+
797+ /* inform ALSA middle layer about transfer status */
798+ snd_pcm_period_elapsed(substream);
799+ mcf_edma_confirm_interrupt_handled(DMA_RX_TCD0);
800+ mcf_edma_confirm_interrupt_handled(DMA_RX_TCD1);
801+
802+ return IRQ_HANDLED;
803+}
804+
805+int ssi_audio_dma_request_playback_channel(struct snd_pcm_substream *substream)
806+{
807+ int err;
808+ struct chip_spec *chip = snd_pcm_substream_chip(substream);
809+
810+ /* request eDMA channel */
811+ err = mcf_edma_request_channel(DMA_TX_TCD0,
812+ ssi_audio_dma_playback_handler,
813+ NULL,
814+ MCF_SSI_AUDIO_IRQ_LEVEL,
815+ substream,
816+ &(chip->audio_device->lock),
817+ id);
818+ if (err < 0)
819+ return err;
820+ err = mcf_edma_request_channel(DMA_TX_TCD1,
821+ ssi_audio_dma_playback_handler,
822+ NULL,
823+ MCF_SSI_AUDIO_IRQ_LEVEL,
824+ substream,
825+ &(chip->audio_device->lock),
826+ id);
827+ return err;
828+}
829+
830+int ssi_audio_dma_request_capture_channel(struct snd_pcm_substream *substream)
831+{
832+ int err;
833+ struct chip_spec *chip = snd_pcm_substream_chip(substream);
834+
835+ /* request 2 eDMA channels for two fifo */
836+ err = mcf_edma_request_channel(DMA_RX_TCD0,
837+ ssi_audio_dma_capture_handler,
838+ NULL,
839+ MCF_SSI_AUDIO_IRQ_LEVEL,
840+ substream,
841+ &(chip->audio_device->lock),
842+ id);
843+ if (err < 0)
844+ return err;
845+ err = mcf_edma_request_channel(DMA_RX_TCD1,
846+ ssi_audio_dma_capture_handler,
847+ NULL,
848+ MCF_SSI_AUDIO_IRQ_LEVEL,
849+ substream,
850+ &(chip->audio_device->lock),
851+ id);
852+ return err;
853+}
854+
855+static inline void ssi_audio_init_dma(void)
856+{
857+ /* SSI DMA Signals mapped to DMA request */
858+ MCF_CCM_MISCCR &= ~MCF_CCM_MISCCR_TIM_DMA;
859+}
860+
861+static void ssi_audio_adjust_codec_speed(struct snd_pcm_substream *substream)
862+{
863+ ssi_audio_disable_ssi();
864+
865+ if (substream->runtime->format == SNDRV_PCM_FORMAT_S16_BE) {
866+ MCF_SSI_CCR = MCF_SSI_CCR_WL(7) | /* 16 bit word length */
867+ MCF_SSI_CCR_DC(1); /* Frame rate divider */
868+ }
869+
870+ switch (substream->runtime->rate) {
871+ case 8000:
872+#if defined(CONFIG_M532x) || defined(CONFIG_M537x)
873+ MCF_CCM_CDR = (MCF_CCM_CDR | MCF_CCM_CDR_SSIDIV(0x20))
874+ | MCF_CCM_CDR_SSIDIV(MCF_SSI_AUDIO_SSDIV_VALUE_1);
875+#else
876+ MCF_CCM_CDR = (MCF_CCM_CDR & ~MCF_CCM_CDR_SSIDIV(0xFF)) |
877+ MCF_CCM_CDR_SSIDIV(MCF_SSI_AUDIO_SSDIV_VALUE_1);
878+#endif
879+ MCF_SSI_CCR |= MCF_SSI_CCR_PM(11);
880+ mcf_codec_spi_write(TLV320AIC23_CODEC_SAMPLE_RATE_REG,
881+ TLV320AIC23_CODEC_SAMPLERATE_REG_8KHZ);
882+ break;
883+ case 11000:
884+ case 11025:
885+#if defined(CONFIG_M532x) || defined(CONFIG_M537x)
886+ MCF_CCM_CDR = (MCF_CCM_CDR & ~MCF_CCM_CDR_SSIDIV(0x3F)) |
887+ MCF_CCM_CDR_SSIDIV(0x2B);
888+ MCF_SSI_CCR |= MCF_SSI_CCR_PM(11);
889+#else
890+ MCF_CCM_CDR = (MCF_CCM_CDR & ~MCF_CCM_CDR_SSIDIV(0xFF)) |
891+ MCF_CCM_CDR_SSIDIV(MCF_SSI_AUDIO_SSDIV_VALUE_3);
892+ MCF_SSI_CCR |= MCF_SSI_CCR_PM(9);
893+#endif
894+ mcf_codec_spi_write(TLV320AIC23_CODEC_SAMPLE_RATE_REG,
895+ TLV320AIC23_CODEC_SAMPLERATE_REG_11KHZ);
896+ break;
897+ case 16000:
898+#if defined(CONFIG_M532x) || defined(CONFIG_M537x)
899+ MCF_CCM_CDR = (MCF_CCM_CDR | MCF_CCM_CDR_SSIDIV(0x20))
900+ | MCF_CCM_CDR_SSIDIV(MCF_SSI_AUDIO_SSDIV_VALUE_1);
901+#else
902+ MCF_CCM_CDR = (MCF_CCM_CDR & ~MCF_CCM_CDR_SSIDIV(0xFF)) |
903+ MCF_CCM_CDR_SSIDIV(MCF_SSI_AUDIO_SSDIV_VALUE_1);
904+#endif
905+ MCF_SSI_CCR |= MCF_SSI_CCR_PM(5);
906+ mcf_codec_spi_write(TLV320AIC23_CODEC_SAMPLE_RATE_REG,
907+ TLV320AIC23_CODEC_SAMPLERATE_REG_16KHZ);
908+ break;
909+ case 22000:
910+ case 22050:
911+#if defined(CONFIG_M532x) || defined(CONFIG_M537x)
912+ MCF_CCM_CDR = (MCF_CCM_CDR & ~MCF_CCM_CDR_SSIDIV(0x3F)) |
913+ MCF_CCM_CDR_SSIDIV(0x2B);
914+ MCF_SSI_CCR |= MCF_SSI_CCR_PM(5);
915+#else
916+ MCF_CCM_CDR = (MCF_CCM_CDR & ~MCF_CCM_CDR_SSIDIV(0xFF)) |
917+ MCF_CCM_CDR_SSIDIV(MCF_SSI_AUDIO_SSDIV_VALUE_3);
918+ MCF_SSI_CCR |= MCF_SSI_CCR_PM(4);
919+#endif
920+ mcf_codec_spi_write(TLV320AIC23_CODEC_SAMPLE_RATE_REG,
921+ TLV320AIC23_CODEC_SAMPLERATE_REG_22KHZ);
922+ break;
923+ case 48000:
924+#if defined(CONFIG_M532x) || defined(CONFIG_M537x)
925+ MCF_CCM_CDR = (MCF_CCM_CDR & ~MCF_CCM_CDR_SSIDIV(0x3F)) |
926+ MCF_CCM_CDR_SSIDIV(MCF_SSI_AUDIO_SSDIV_VALUE_4);
927+ MCF_SSI_CCR |= MCF_SSI_CCR_PM(3);
928+#else
929+ MCF_CCM_CDR = (MCF_CCM_CDR & ~MCF_CCM_CDR_SSIDIV(0xFF)) |
930+ MCF_CCM_CDR_SSIDIV(MCF_SSI_AUDIO_SSDIV_VALUE_1);
931+ MCF_SSI_CCR |= MCF_SSI_CCR_PM(1);
932+#endif
933+ mcf_codec_spi_write(TLV320AIC23_CODEC_SAMPLE_RATE_REG,
934+ TLV320AIC23_CODEC_SAMPLERATE_REG_48KHZ);
935+ break;
936+ case 44000:
937+ case 44100:
938+ default:
939+#if defined(CONFIG_M532x) || defined(CONFIG_M537x)
940+ MCF_CCM_CDR = (MCF_CCM_CDR & ~MCF_CCM_CDR_SSIDIV(0x3F)) |
941+ MCF_CCM_CDR_SSIDIV(0x2B);
942+#else
943+ MCF_CCM_CDR = (MCF_CCM_CDR & ~MCF_CCM_CDR_SSIDIV(0xFF)) |
944+ MCF_CCM_CDR_SSIDIV(MCF_SSI_AUDIO_SSDIV_VALUE_2);
945+#endif
946+ MCF_SSI_CCR |= MCF_SSI_CCR_PM(2);
947+ mcf_codec_spi_write(TLV320AIC23_CODEC_SAMPLE_RATE_REG,
948+ TLV320AIC23_CODEC_SAMPLERATE_REG_44KHZ);
949+ break;
950+ }
951+ DBG("MCF_CCM_CDR = 0x%x, MCF_SSI_CCR = 0x%x.\n",
952+ MCF_CCM_CDR, MCF_SSI_CCR);
953+}
954+
955+static void ssi_audio_codec_reset(void)
956+{
957+ mcf_codec_spi_write(CODEC_RESET_REG, 0); /* reset the audio chip */
958+ udelay(2500); /* wait for reset */
959+}
960+
961+static void
962+ssi_audio_init_codec_for_playback(struct snd_pcm_substream *substream)
963+{
964+ mcf_codec_spi_write(CODEC_LEFT_IN_REG, g_lineinvol);
965+ mcf_codec_spi_write(CODEC_RIGHT_IN_REG, g_lineinvol);
966+ mcf_codec_spi_write(CODEC_POWER_DOWN_REG, 0x060);
967+ mcf_codec_spi_write(CODEC_DIGITAL_IF_FMT_REG, 0x02);
968+ mcf_codec_spi_write(CODEC_DIGITAL_APATH_REG, 0x006);
969+ mcf_codec_spi_write(CODEC_DIGITAL_IF_ACT_REG, 0x001);
970+ mcf_codec_spi_write(CODEC_ANALOG_APATH_REG, g_analogpath);
971+ mcf_codec_spi_write(CODEC_LEFT_HP_VOL_REG, g_mastervol);
972+ mcf_codec_spi_write(CODEC_RIGHT_HP_VOL_REG, g_mastervol);
973+}
974+
975+static void
976+ssi_audio_init_codec_for_capture(struct snd_pcm_substream *substream)
977+{
978+ mcf_codec_spi_write(CODEC_LEFT_IN_REG, g_lineinvol);
979+ mcf_codec_spi_write(CODEC_RIGHT_IN_REG, g_lineinvol);
980+ mcf_codec_spi_write(CODEC_POWER_DOWN_REG, 0x060);
981+ mcf_codec_spi_write(CODEC_DIGITAL_IF_FMT_REG, 0x02);
982+ mcf_codec_spi_write(CODEC_DIGITAL_APATH_REG, 0x006);
983+ mcf_codec_spi_write(CODEC_DIGITAL_IF_ACT_REG, 0x001);
984+ mcf_codec_spi_write(CODEC_ANALOG_APATH_REG, g_analogpath);
985+ mcf_codec_spi_write(CODEC_LEFT_HP_VOL_REG, g_mastervol);
986+ mcf_codec_spi_write(CODEC_RIGHT_HP_VOL_REG, g_mastervol);
987+}
988+
989+static void ssi_audio_chip_init(void)
990+{
991+ int chip_initialized = 0;
992+ if (chip_initialized == 1)
993+ return;
994+
995+ ssi_audio_init_dma();
996+ /* Enable the SSI pins */
997+#if defined(CONFIG_M5227x)
998+ MCF_GPIO_PAR_UART = (MCF_GPIO_PAR_UART
999+ &~MCF_GPIO_PAR_UART_PAR_U1TXD(0xF)
1000+ &~MCF_GPIO_PAR_UART_PAR_U1RXD(0xF)
1001+ &~MCF_GPIO_PAR_UART_PAR_U1RTS(0xF)
1002+ &~MCF_GPIO_PAR_UART_PAR_U1CTS(0xF))
1003+ | MCF_GPIO_PAR_UART_PAR_U1CTS_SSI_BCLK
1004+ | MCF_GPIO_PAR_UART_PAR_U1RTS_SSI_FS
1005+ | MCF_GPIO_PAR_UART_PAR_U1RXD_SSI_RXD
1006+ | MCF_GPIO_PAR_UART_PAR_U1TXD_SSI_TXD;
1007+
1008+ MCF_GPIO_PAR_TIMER = (MCF_GPIO_PAR_TIMER
1009+ &~MCF_GPIO_PAR_TIMER_PAR_T3IN(0xF))
1010+ | MCF_GPIO_PAR_TIMER_PAR_T3IN_SSI_MCLK;
1011+#endif
1012+#if defined(CONFIG_M532x)
1013+ MCF_GPIO_PAR_SSI = (0
1014+ | MCF_GPIO_PAR_SSI_PAR_MCLK
1015+ | MCF_GPIO_PAR_SSI_PAR_TXD(3)
1016+ | MCF_GPIO_PAR_SSI_PAR_RXD(3)
1017+ | MCF_GPIO_PAR_SSI_PAR_FS(3)
1018+ | MCF_GPIO_PAR_SSI_PAR_BCLK(3));
1019+#endif
1020+#if defined(CONFIG_M537x)
1021+ MCF_GPIO_PAR_UART = (MCF_GPIO_PAR_UART
1022+ &~MCF_GPIO_PAR_UART_PAR_UTXD1(0xF)
1023+ &~MCF_GPIO_PAR_UART_PAR_URXD1(0xF)
1024+ &~MCF_GPIO_PAR_UART_PAR_URTS1(0xF)
1025+ &~MCF_GPIO_PAR_UART_PAR_UCTS1(0xF))
1026+ | MCF_GPIO_PAR_UART_PAR_UCTS1_SSI_BCLK
1027+ | MCF_GPIO_PAR_UART_PAR_URTS1_SSI_FS
1028+ | MCF_GPIO_PAR_UART_PAR_URXD1_SSI_RXD
1029+ | MCF_GPIO_PAR_UART_PAR_UTXD1_SSI_TXD;
1030+
1031+ MCF_GPIO_PAR_IRQ = MCF_GPIO_PAR_IRQ_PAR_IRQ4(1);
1032+#endif
1033+#if defined(CONFIG_M5301x)
1034+ MCF_GPIO_PAR_SSIH = (MCF_GPIO_PAR_SSIH_PAR_RXD_SSI_RXD |
1035+ MCF_GPIO_PAR_SSIH_PAR_TXD_SSI_TXD |
1036+ MCF_GPIO_PAR_SSIH_PAR_FS_SSI_FS |
1037+ MCF_GPIO_PAR_SSIH_PAR_MCLK_SSI_MCLK);
1038+ MCF_GPIO_PAR_SSIL = MCF_GPIO_PAR_SSIL_PAR_BCLK_SSI_BCLK;
1039+#endif
1040+#if defined(CONFIG_M5445X)
1041+ MCF_GPIO_PAR_SSI = (MCF_GPIO_PAR_SSI_MCLK |
1042+ MCF_GPIO_PAR_SSI_STXD_STXD |
1043+ MCF_GPIO_PAR_SSI_SRXD_SRXD |
1044+ MCF_GPIO_PAR_SSI_FS_FS |
1045+ MCF_GPIO_PAR_SSI_BCLK_BCLK);
1046+#endif
1047+ chip_initialized = 1;
1048+}
1049+
1050+static void ssi_audio_init_ssi_playback(void)
1051+{
1052+ /* Issue a SSI reset */
1053+ MCF_SSI_CR &= ~MCF_SSI_CR_SSI_EN;
1054+
1055+ /* SSI module uses internal CPU clock */
1056+ MCF_CCM_MISCCR |= MCF_CCM_MISCCR_SSI_SRC;
1057+#if defined(CONFIG_M5445X) || defined(CONFIG_M532x) || defined(CONFIG_M537x) \
1058+ || defined(CONFIG_M5227x)
1059+ MCF_CCM_MISCCR |= MCF_CCM_MISCCR_SSI_PUE | MCF_CCM_MISCCR_SSI_PUS;
1060+#endif
1061+#if defined(CONFIG_M5301x)
1062+ MCF_GPIO_PCRH |= MCF_GPIO_PCRH_SSI_PUS | MCF_GPIO_PCRH_SSI_PUE;
1063+#endif
1064+ MCF_SSI_CR = MCF_SSI_CR_CIS |
1065+ MCF_SSI_CR_TCH | /* Enable two channel mode */
1066+ MCF_SSI_CR_MCE | /* clock out on SSI_MCLK pin */
1067+ MCF_SSI_CR_I2S_MASTER | /* I2S master mode */
1068+ MCF_SSI_CR_SYN | /* Enable synchronous mode */
1069+ MCF_SSI_CR_NET; /* Auto set by I2S Master */
1070+
1071+ MCF_SSI_TCR = 0 |
1072+ /* internally generated bit clock */
1073+ MCF_SSI_TCR_TXDIR |
1074+ /* internally generated frame sync */
1075+ MCF_SSI_TCR_TFDIR |
1076+ /* Clock data on falling edge of bit clock */
1077+ MCF_SSI_TCR_TSCKP |
1078+ /* Frame sync active low */
1079+ MCF_SSI_TCR_TFSI |
1080+ /* TX frame sync 1 bit before data */
1081+ MCF_SSI_TCR_TEFS |
1082+ /* TX FIFO 0 enabled */
1083+ MCF_SSI_TCR_TFEN0 |
1084+ /* TX FIFO 1 enabled */
1085+ MCF_SSI_TCR_TFEN1 |
1086+ MCF_SSI_TCR_TXBIT0;
1087+
1088+ MCF_SSI_FCSR = MCF_SSI_FCSR_TFWM0(TXFWM) | MCF_SSI_FCSR_TFWM1(TXFWM);
1089+
1090+ MCF_SSI_IER = MCF_SSI_IER_TDMAE | /* DMA request enabled */
1091+ MCF_SSI_IER_TFE0 |
1092+ MCF_SSI_IER_TFE1; /* set by reset actually*/
1093+}
1094+
1095+static void ssi_audio_init_ssi_capture(void)
1096+{
1097+ /* Issue a SSI reset */
1098+ MCF_SSI_CR &= ~MCF_SSI_CR_SSI_EN;
1099+
1100+ /* SSI module uses internal CPU clock */
1101+ MCF_CCM_MISCCR |= MCF_CCM_MISCCR_SSI_SRC;
1102+#if defined(CONFIG_M5445X) || defined(CONFIG_M532x) || defined(CONFIG_M537x) \
1103+ || defined(CONFIG_M5227x)
1104+ MCF_CCM_MISCCR |= MCF_CCM_MISCCR_SSI_PUE | MCF_CCM_MISCCR_SSI_PUS;
1105+#endif
1106+#if defined(CONFIG_M5301x)
1107+ MCF_GPIO_PCRH |= MCF_GPIO_PCRH_SSI_PUS | MCF_GPIO_PCRH_SSI_PUE;
1108+#endif
1109+ MCF_SSI_CR = MCF_SSI_CR_CIS |
1110+ MCF_SSI_CR_TCH | /* Enable two channel mode */
1111+ MCF_SSI_CR_MCE | /* clock out on SSI_MCLK pin */
1112+ MCF_SSI_CR_I2S_MASTER | /* I2S master mode */
1113+ MCF_SSI_CR_SYN | /* Enable synchronous mode */
1114+ MCF_SSI_CR_NET; /* Auto set by I2S Master */
1115+
1116+ MCF_SSI_TCR = 0 |
1117+ /* internally generated bit clock */
1118+ MCF_SSI_TCR_TXDIR |
1119+ /* internally generated frame sync */
1120+ MCF_SSI_TCR_TFDIR |
1121+ /* Clock data on falling edge of bit clock */
1122+ MCF_SSI_TCR_TSCKP |
1123+ /* Frame sync active low */
1124+ MCF_SSI_TCR_TFSI |
1125+ /* TX frame sync 1 bit before data */
1126+ MCF_SSI_TCR_TEFS |
1127+ /* TX FIFO 0 enabled */
1128+ MCF_SSI_TCR_TFEN0 |
1129+ /* TX FIFO 1 enabled */
1130+ MCF_SSI_TCR_TFEN1 |
1131+ MCF_SSI_TCR_TXBIT0;
1132+
1133+ MCF_SSI_RCR = 0 |
1134+ /* Clock data on rising edge of bit clock */
1135+ MCF_SSI_RCR_RSCKP |
1136+ /* Frame sync active low */
1137+ MCF_SSI_RCR_RFSI |
1138+ /* RX frame sync 1 bit before data */
1139+ MCF_SSI_RCR_REFS |
1140+ /* RX FIFO 0 enabled */
1141+ MCF_SSI_RCR_RFEN0 |
1142+ /* RX FIFO 1 enabled */
1143+ MCF_SSI_RCR_RFEN1 |
1144+ MCF_SSI_RCR_RXBIT0; /* Auto set by I2S Master */
1145+
1146+ MCF_SSI_FCSR = MCF_SSI_FCSR_RFWM0(RXFWM) | MCF_SSI_FCSR_RFWM1(RXFWM);
1147+
1148+ /* interrupts */
1149+ MCF_SSI_IER = MCF_SSI_IER_RDMAE | /* DMA request enabled */
1150+ MCF_SSI_IER_RFF0 | /* rx FIFO 0 full */
1151+ MCF_SSI_IER_RFF1; /* rx FIFO 1 full */
1152+}
1153+
1154+static int snd_coldfire_playback_open(struct snd_pcm_substream *substream)
1155+{
1156+ int err;
1157+ struct chip_spec *chip = snd_pcm_substream_chip(substream);
1158+ struct snd_pcm_runtime *runtime = substream->runtime;
1159+ struct dma_private *dma_private;
1160+ dma_addr_t tcd_buf_phys;
1161+
1162+ runtime->hw = snd_coldfire_playback_hw;
1163+ err = snd_pcm_hw_constraint_integer(runtime,
1164+ SNDRV_PCM_HW_PARAM_PERIODS);
1165+ if (err < 0) {
1166+ printk(KERN_ERR "invalid buffer size\n");
1167+ return err;
1168+ }
1169+ /* to make sure period_bytes is the multiple of size of minor loops */
1170+ err = snd_pcm_hw_constraint_step(runtime, 0,
1171+ SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
1172+ HW_PERIODS_BYTES_STEP);
1173+ if (err < 0) {
1174+ printk(KERN_ERR "Error setting period_bytes step, "
1175+ "err=%d\n", err);
1176+ return err;
1177+ }
1178+ err = snd_pcm_hw_constraint_list(substream->runtime, 0,
1179+ SNDRV_PCM_HW_PARAM_RATE,
1180+ &constraints_rates);
1181+ if (err < 0) {
1182+ printk(KERN_ERR "Error setting rate constraints, "
1183+ "err=%d\n", err);
1184+ return err;
1185+ }
1186+ ssi_audio_chip_init();
1187+ ssi_audio_init_ssi_playback();
1188+ ssi_audio_init_codec_for_playback(substream);
1189+ err = ssi_audio_dma_request_playback_channel(substream);
1190+ if (err < 0) {
1191+ printk(KERN_ERR "Error requesting dma channel, err=%d\n", err);
1192+ return err;
1193+ }
1194+
1195+ dma_private = dma_alloc_coherent(substream->pcm->dev,
1196+ sizeof(struct dma_private), &tcd_buf_phys, GFP_KERNEL);
1197+
1198+ if (!dma_private) {
1199+ dev_err(substream->pcm->card->dev,
1200+ "can't allocate DMA private data\n");
1201+ return -ENOMEM;
1202+ }
1203+
1204+ dma_private->tcd_buf_phys = tcd_buf_phys;
1205+ runtime->private_data = dma_private;
1206+
1207+ chip->offset = 0;
1208+ g_tx_dmaing = 0;
1209+ return 0;
1210+}
1211+
1212+static int snd_coldfire_capture_open(struct snd_pcm_substream *substream)
1213+{
1214+ int err;
1215+ struct chip_spec *chip = snd_pcm_substream_chip(substream);
1216+ struct snd_pcm_runtime *runtime = substream->runtime;
1217+ struct dma_private *dma_private;
1218+ dma_addr_t tcd_buf_phys;
1219+
1220+ runtime->hw = snd_coldfire_capture_hw;
1221+
1222+ err = snd_pcm_hw_constraint_integer(runtime,
1223+ SNDRV_PCM_HW_PARAM_PERIODS);
1224+ if (err < 0) {
1225+ printk(KERN_ERR "invalid buffer size\n");
1226+ return err;
1227+ }
1228+ /* to make sure period_bytes is the multiple of size of minor loops */
1229+ err = snd_pcm_hw_constraint_step(runtime, 0,
1230+ SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
1231+ HW_PERIODS_BYTES_STEP);
1232+ if (err < 0) {
1233+ printk(KERN_ERR "Error setting period_bytes step, "
1234+ "err=%d\n", err);
1235+ return err;
1236+ }
1237+ err = snd_pcm_hw_constraint_list(substream->runtime, 0,
1238+ SNDRV_PCM_HW_PARAM_RATE,
1239+ &constraints_rates);
1240+ if (err < 0) {
1241+ printk(KERN_ERR "Error setting pcm_hw_constraint_list, "
1242+ "err=%d\n", err);
1243+ return err;
1244+ }
1245+
1246+ ssi_audio_chip_init();
1247+ ssi_audio_init_ssi_capture();
1248+ ssi_audio_init_codec_for_capture(substream);
1249+ err = ssi_audio_dma_request_capture_channel(substream);
1250+ if (err < 0) {
1251+ printk(KERN_ERR "Error requesting dma channel, err=%d\n", err);
1252+ return err;
1253+ }
1254+
1255+ dma_private = dma_alloc_coherent(substream->pcm->dev,
1256+ sizeof(struct dma_private), &tcd_buf_phys, GFP_KERNEL);
1257+
1258+ if (!dma_private) {
1259+ dev_err(substream->pcm->card->dev,
1260+ "can't allocate DMA private data\n");
1261+ return -ENOMEM;
1262+ }
1263+ dma_private->tcd_buf_phys = tcd_buf_phys;
1264+ dma_private->dma_buf_phys = substream->dma_buffer.addr;
1265+
1266+ runtime->private_data = dma_private;
1267+
1268+ chip->offset = 0;
1269+ g_rx_dmaing = 0;
1270+ return 0;
1271+}
1272+
1273+static int snd_coldfire_playback_close(struct snd_pcm_substream *substream)
1274+{
1275+ struct dma_private *dma_private = substream->runtime->private_data;
1276+
1277+ ssi_audio_dma_playback_stop();
1278+ mcf_edma_free_channel(DMA_TX_TCD0, substream);
1279+ mcf_edma_free_channel(DMA_TX_TCD1, substream);
1280+ if (dma_private) {
1281+ dma_free_coherent(substream->pcm->dev,
1282+ sizeof(struct dma_private),
1283+ dma_private, dma_private->tcd_buf_phys);
1284+ substream->runtime->private_data = NULL;
1285+ }
1286+ ssi_audio_disable_ssi();
1287+ return 0;
1288+}
1289+
1290+static int snd_coldfire_capture_close(struct snd_pcm_substream *substream)
1291+{
1292+ struct dma_private *dma_private = substream->runtime->private_data;
1293+
1294+ ssi_audio_dma_capture_stop();
1295+ mcf_edma_free_channel(DMA_RX_TCD0, substream);
1296+ mcf_edma_free_channel(DMA_RX_TCD1, substream);
1297+ /* Deallocate the fsl_dma_private structure */
1298+ if (dma_private) {
1299+ dma_free_coherent(substream->pcm->dev,
1300+ sizeof(struct dma_private),
1301+ dma_private, dma_private->tcd_buf_phys);
1302+ substream->runtime->private_data = NULL;
1303+ }
1304+ ssi_audio_disable_ssi();
1305+ return 0;
1306+}
1307+
1308+static int snd_coldfire_pcm_hw_params(struct snd_pcm_substream *substream,
1309+ struct snd_pcm_hw_params *hw_params)
1310+{
1311+ int err;
1312+
1313+ /* set runtime buffer */
1314+ err = snd_pcm_lib_malloc_pages(
1315+ substream, params_buffer_bytes(hw_params));
1316+ if (err < 0)
1317+ printk(KERN_ERR "Error allocating pages, err=%d\n", err);
1318+ return err;
1319+}
1320+
1321+static int snd_coldfire_pcm_hw_free(struct snd_pcm_substream *substream)
1322+{
1323+ /* free the memory if was newly allocated */
1324+ return snd_pcm_lib_free_pages(substream);
1325+}
1326+
1327+static int
1328+snd_coldfire_pcm_playback_prepare(struct snd_pcm_substream *substream)
1329+{
1330+ int err;
1331+
1332+ if (g_tx_dmaing == 1)
1333+ return 0;
1334+
1335+ ssi_audio_adjust_codec_speed(substream);
1336+ err = ssi_audio_dma_playback_config(substream);
1337+ if (err < 0) {
1338+ printk(KERN_ERR "Error configuring playback, "
1339+ "err=%d\n", err);
1340+ return err;
1341+ }
1342+
1343+ ssi_audio_dma_playback_start();
1344+ return 0;
1345+}
1346+
1347+static int snd_coldfire_pcm_capture_prepare(struct snd_pcm_substream *substream)
1348+{
1349+ int err;
1350+
1351+ if (g_rx_dmaing == 1)
1352+ return 0;
1353+
1354+ ssi_audio_adjust_codec_speed(substream);
1355+ err = ssi_audio_dma_capture_config(substream);
1356+ if (err < 0) {
1357+ printk(KERN_ERR "Error configuring capture, "
1358+ "err=%d\n", err);
1359+ return err;
1360+ }
1361+ ssi_audio_dma_capture_start();
1362+
1363+ return 0;
1364+}
1365+
1366+static int
1367+snd_coldfire_pcm_playback_trigger(struct snd_pcm_substream *substream, int cmd)
1368+{
1369+ switch (cmd) {
1370+ case SNDRV_PCM_TRIGGER_START:
1371+ ssi_audio_enable_ssi_playback();
1372+ break;
1373+ case SNDRV_PCM_TRIGGER_STOP:
1374+ ssi_audio_disable_ssi_playback();
1375+ break;
1376+ default:
1377+ printk(KERN_ERR "Unsupported trigger command, cmd=%d\n", cmd);
1378+ return -EINVAL;
1379+ }
1380+
1381+ return 0;
1382+}
1383+
1384+static int
1385+snd_coldfire_pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd)
1386+{
1387+ switch (cmd) {
1388+ case SNDRV_PCM_TRIGGER_START:
1389+ ssi_audio_enable_ssi_capture();
1390+ break;
1391+ case SNDRV_PCM_TRIGGER_STOP:
1392+ ssi_audio_disable_ssi_capture();
1393+ break;
1394+ default:
1395+ printk(KERN_ERR "Unsupported trigger command, cmd=%d\n", cmd);
1396+ return -EINVAL;
1397+ }
1398+
1399+ return 0;
1400+}
1401+
1402+static snd_pcm_uframes_t
1403+snd_coldfire_pcm_playback_pointer(struct snd_pcm_substream *substream)
1404+{
1405+ struct snd_pcm_runtime *runtime = substream->runtime;
1406+ struct dma_private *dma_private = runtime->private_data;
1407+ snd_pcm_uframes_t pointer;
1408+ u32 offset;
1409+
1410+ offset = (u32)(MCF_EDMA_TCD_SADDR(DMA_TX_TCD0) -
1411+ dma_private->dma_buf_phys);
1412+ if (runtime->format == SNDRV_PCM_FORMAT_S16_BE)
1413+ pointer = offset / (runtime->channels == 1 ? 2 : 4);
1414+ else
1415+ pointer = 0;
1416+
1417+ return pointer;
1418+}
1419+
1420+static snd_pcm_uframes_t
1421+snd_coldfire_pcm_capture_pointer(struct snd_pcm_substream *substream)
1422+{
1423+ struct snd_pcm_runtime *runtime = substream->runtime;
1424+ struct dma_private *dma_private = runtime->private_data;
1425+ snd_pcm_uframes_t pointer;
1426+ u32 offset;
1427+
1428+ offset = (u32)(MCF_EDMA_TCD_DADDR(DMA_RX_TCD0) -
1429+ dma_private->dma_buf_phys);
1430+ if (runtime->format == SNDRV_PCM_FORMAT_S16_BE)
1431+ pointer = offset / (runtime->channels == 1 ? 2 : 4);
1432+ else
1433+ pointer = 0;
1434+
1435+ return pointer;
1436+}
1437+
1438+static struct snd_pcm_ops snd_coldfire_playback_ops = {
1439+ .open = snd_coldfire_playback_open,
1440+ .close = snd_coldfire_playback_close,
1441+ .ioctl = snd_pcm_lib_ioctl,
1442+ .hw_params = snd_coldfire_pcm_hw_params,
1443+ .hw_free = snd_coldfire_pcm_hw_free,
1444+ .prepare = snd_coldfire_pcm_playback_prepare,
1445+ .trigger = snd_coldfire_pcm_playback_trigger,
1446+ .pointer = snd_coldfire_pcm_playback_pointer,
1447+};
1448+
1449+static struct snd_pcm_ops snd_coldfire_capture_ops = {
1450+ .open = snd_coldfire_capture_open,
1451+ .close = snd_coldfire_capture_close,
1452+ .ioctl = snd_pcm_lib_ioctl,
1453+ .hw_params = snd_coldfire_pcm_hw_params,
1454+ .hw_free = snd_coldfire_pcm_hw_free,
1455+ .prepare = snd_coldfire_pcm_capture_prepare,
1456+ .trigger = snd_coldfire_pcm_capture_trigger,
1457+ .pointer = snd_coldfire_pcm_capture_pointer,
1458+};
1459+
1460+static int snd_coldfire_new_pcm(struct chip_spec *chip)
1461+{
1462+ struct snd_pcm *pcm;
1463+ int err;
1464+
1465+ err = snd_pcm_new(chip->card, "coldfire", 0, 1, 1,
1466+ &pcm);
1467+ if (err < 0) {
1468+ printk(KERN_ERR "Error creating new pcm, err=%d\n", err);
1469+ return err;
1470+ }
1471+ pcm->private_data = chip;
1472+ strncpy(pcm->name, SOUND_CARD_NAME, sizeof(pcm->name));
1473+ chip->pcm = pcm;
1474+ pcm->info_flags = 0;
1475+
1476+ /* set operators */
1477+ snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
1478+ &snd_coldfire_playback_ops);
1479+ snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
1480+ &snd_coldfire_capture_ops);
1481+ /* pre-allocation of buffers */
1482+ err = snd_pcm_lib_preallocate_pages_for_all(
1483+ pcm,
1484+ SNDRV_DMA_TYPE_CONTINUOUS,
1485+ snd_dma_continuous_data(GFP_KERNEL),
1486+ MAX_BUFFER_SIZE,
1487+ MAX_BUFFER_SIZE);
1488+
1489+ if (!pcm->streams[0].substream->dma_buffer.addr)
1490+ pcm->streams[0].substream->dma_buffer.addr =
1491+ virt_to_phys(pcm->streams[0].substream->dma_buffer.area);
1492+ if (!pcm->streams[1].substream->dma_buffer.addr)
1493+ pcm->streams[1].substream->dma_buffer.addr =
1494+ virt_to_phys(pcm->streams[1].substream->dma_buffer.area);
1495+
1496+ if (err) {
1497+ printk(KERN_ERR
1498+ "Can't pre-allocate DMA buffer (size=%u)\n",
1499+ MAX_BUFFER_SIZE);
1500+ return -ENOMEM;
1501+ }
1502+
1503+ chip->audio_device =
1504+ kmalloc(sizeof(struct tlv320a_audio_device), GFP_DMA);
1505+
1506+ if (!chip->audio_device) {
1507+ snd_pcm_lib_preallocate_free_for_all(pcm);
1508+ printk(KERN_ERR
1509+ "Can't allocate buffer for audio device\n");
1510+ return -ENOMEM;
1511+ }
1512+
1513+ return 0;
1514+}
1515+
1516+static int tlv320a_set_out_volume(unsigned char value)
1517+{
1518+ unsigned char data;
1519+
1520+ if (value > TLV320A_VOL_MAX)
1521+ data = TLV320A_VOL_MAX;
1522+ else
1523+ data = value;
1524+
1525+ if (mcf_codec_spi_write(CODEC_LEFT_HP_VOL_REG, data) < 0)
1526+ return -EINVAL;
1527+
1528+ if (mcf_codec_spi_write(CODEC_RIGHT_HP_VOL_REG, data) < 0)
1529+ return -EINVAL;
1530+
1531+ return 0;
1532+}
1533+
1534+static int tlv320a_info_out_volume(struct snd_kcontrol *kcontrol,
1535+ struct snd_ctl_elem_info *uinfo)
1536+{
1537+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1538+ uinfo->count = 1;
1539+ uinfo->value.integer.min = TLV320A_VOL_MIN;
1540+ uinfo->value.integer.max = TLV320A_VOL_MAX;
1541+ return 0;
1542+}
1543+
1544+static int tlv320a_get_out_volume(struct snd_kcontrol *kcontrol,
1545+ struct snd_ctl_elem_value *ucontrol)
1546+{
1547+ ucontrol->value.integer.value[0] = g_mastervol;
1548+ return 0;
1549+}
1550+
1551+static int tlv320a_put_out_volume(struct snd_kcontrol *kcontrol,
1552+ struct snd_ctl_elem_value *ucontrol)
1553+{
1554+ unsigned char vol;
1555+ int change;
1556+
1557+ vol = ucontrol->value.integer.value[0];
1558+
1559+ if (vol > TLV320A_VOL_MAX)
1560+ return -EINVAL;
1561+
1562+ change = (g_mastervol != vol);
1563+ if (change) {
1564+ g_mastervol = vol;
1565+ tlv320a_set_out_volume(vol);
1566+ }
1567+ return change;
1568+}
1569+
1570+static int tlv320a_set_linein_volume(unsigned char value)
1571+{
1572+ unsigned char data;
1573+
1574+ if (value > TLV320A_LINEIN_MAX)
1575+ data = TLV320A_LINEIN_MAX;
1576+ else
1577+ data = value;
1578+
1579+ if (mcf_codec_spi_write(CODEC_LEFT_IN_REG, data) < 0)
1580+ return -EINVAL;
1581+
1582+ if (mcf_codec_spi_write(CODEC_RIGHT_IN_REG, data) < 0)
1583+ return -EINVAL;
1584+
1585+ return 0;
1586+}
1587+
1588+static int tlv320a_info_linein_volume(struct snd_kcontrol *kcontrol,
1589+ struct snd_ctl_elem_info *uinfo)
1590+{
1591+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1592+ uinfo->count = 1;
1593+ uinfo->value.integer.min = 0;
1594+ uinfo->value.integer.max = TLV320A_LINEIN_MAX;
1595+ return 0;
1596+}
1597+
1598+static int tlv320a_get_linein_volume(struct snd_kcontrol *kcontrol,
1599+ struct snd_ctl_elem_value *ucontrol)
1600+{
1601+ ucontrol->value.integer.value[0] = g_lineinvol;
1602+ return 0;
1603+}
1604+
1605+static int tlv320a_put_linein_volume(struct snd_kcontrol *kcontrol,
1606+ struct snd_ctl_elem_value *ucontrol)
1607+{
1608+ unsigned char vol;
1609+ int change;
1610+
1611+ vol = ucontrol->value.integer.value[0];
1612+
1613+ if (vol > TLV320A_LINEIN_MAX)
1614+ return -EINVAL;
1615+
1616+ change = (g_lineinvol != vol);
1617+ if (change) {
1618+ g_lineinvol = vol;
1619+ tlv320a_set_linein_volume(vol);
1620+ }
1621+ return change;
1622+}
1623+
1624+#define tlv320a_info_mic_boost snd_ctl_boolean_mono_info
1625+static int tlv320a_get_mic_boost(struct snd_kcontrol *kcontrol,
1626+ struct snd_ctl_elem_value *ucontrol)
1627+{
1628+ ucontrol->value.integer.value[0] = ((g_analogpath & 0x1) == 1);
1629+ return 0;
1630+}
1631+
1632+static int tlv320a_put_mic_boost(struct snd_kcontrol *kcontrol,
1633+ struct snd_ctl_elem_value *ucontrol)
1634+{
1635+ int oldboost, newboost;
1636+ u8 data;
1637+ if (ucontrol->value.integer.value[0] == 1)
1638+ newboost = 1;
1639+ else
1640+ newboost = 0;
1641+ oldboost = g_analogpath & 0x1;
1642+
1643+ if (oldboost == newboost)
1644+ return 0;
1645+ data = (g_analogpath & 0xfe) | (newboost & 0x1);
1646+ if (mcf_codec_spi_write(CODEC_ANALOG_APATH_REG, data) < 0)
1647+ return -EINVAL;
1648+ g_analogpath = data;
1649+ return 1;
1650+}
1651+
1652+static int tlv320a_info_capture_source(struct snd_kcontrol *kcontrol,
1653+ struct snd_ctl_elem_info *uinfo)
1654+{
1655+ static char *texts[] = { "Line-In", "Microphone" };
1656+
1657+ uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1658+ uinfo->count = 1;
1659+ uinfo->value.enumerated.items = 2;
1660+ if (uinfo->value.enumerated.item > 1)
1661+ uinfo->value.enumerated.item = 1;
1662+ strcpy(uinfo->value.enumerated.name,
1663+ texts[uinfo->value.enumerated.item]);
1664+ return 0;
1665+}
1666+
1667+static int tlv320a_get_capture_source(struct snd_kcontrol *kcontrol,
1668+ struct snd_ctl_elem_value *ucontrol)
1669+{
1670+
1671+ ucontrol->value.enumerated.item[0] = ((g_analogpath & 0x4) == 0x4);
1672+ return 0;
1673+}
1674+
1675+static int tlv320a_put_capture_source(struct snd_kcontrol *kcontrol,
1676+ struct snd_ctl_elem_value *ucontrol)
1677+{
1678+ int oldinput, newinput;
1679+ u8 data;
1680+
1681+ if (ucontrol->value.enumerated.item[0] > 1)
1682+ return -EINVAL;
1683+
1684+ oldinput = (g_analogpath & 0x4) ? INPUT_MICROPHONE : INPUT_LINEIN;
1685+
1686+ if (ucontrol->value.enumerated.item[0])
1687+ newinput = INPUT_MICROPHONE;
1688+ else
1689+ newinput = INPUT_LINEIN;
1690+ if (oldinput == newinput)
1691+ return 0;
1692+ data = (g_analogpath & 0xfb) |
1693+ (newinput == INPUT_MICROPHONE ? 0x4 : 0);
1694+ if (mcf_codec_spi_write(CODEC_ANALOG_APATH_REG, data) < 0)
1695+ return -EINVAL;
1696+ g_analogpath = data;
1697+ return 1;
1698+}
1699+
1700+static struct snd_kcontrol_new tlv320_mixer_out __devinitdata = {
1701+ .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1702+ .name = "play volume",
1703+ .index = 0,
1704+ .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1705+ .info = tlv320a_info_out_volume,
1706+ .get = tlv320a_get_out_volume,
1707+ .put = tlv320a_put_out_volume,
1708+};
1709+
1710+static struct snd_kcontrol_new tlv320_mixer_linein __devinitdata = {
1711+ .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1712+ .name = "record volume",
1713+ .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1714+ .info = tlv320a_info_linein_volume,
1715+ .get = tlv320a_get_linein_volume,
1716+ .put = tlv320a_put_linein_volume,
1717+};
1718+
1719+static struct snd_kcontrol_new tlv320_mixer_capture_source __devinitdata = {
1720+ .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1721+ .name = "record source",
1722+ .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1723+ .info = tlv320a_info_capture_source,
1724+ .get = tlv320a_get_capture_source,
1725+ .put = tlv320a_put_capture_source,
1726+};
1727+
1728+static struct snd_kcontrol_new tlv320_mixer_mic_boost __devinitdata = {
1729+ .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1730+ .name = "mic Boost",
1731+ .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1732+ .info = tlv320a_info_mic_boost,
1733+ .get = tlv320a_get_mic_boost,
1734+ .put = tlv320a_put_mic_boost,
1735+};
1736+
1737+static int __devinit coldfire_alsa_audio_probe(struct platform_device *dev)
1738+{
1739+ struct snd_card *card;
1740+ struct chip_spec *chip;
1741+ int err;
1742+
1743+ err = snd_card_create(-1, id, THIS_MODULE,
1744+ sizeof(struct chip_spec), &card);
1745+ if (err < 0)
1746+ return -ENOMEM;
1747+
1748+ chip = card->private_data;
1749+
1750+ chip->card = card;
1751+ card->dev = &dev->dev;
1752+
1753+ err = snd_coldfire_new_pcm(chip);
1754+ if (err < 0)
1755+ return -ENOMEM;
1756+
1757+ strcpy(card->driver, "coldfire");
1758+ strcpy(card->shortname, "Coldfire-TLV320A");
1759+ sprintf(card->longname, "Freescale Coldfire with TLV320A");
1760+
1761+ err = snd_card_register(card);
1762+ if (err == 0) {
1763+ pr_debug(KERN_INFO "Coldfire audio support initialized\n");
1764+ platform_set_drvdata(dev, card);
1765+ }
1766+
1767+ strcpy(chip->card->mixername, "TLV320A Volume");
1768+ err = snd_ctl_add(chip->card, snd_ctl_new1(&tlv320_mixer_out, chip));
1769+ if (err)
1770+ goto error;
1771+ err = snd_ctl_add(chip->card, snd_ctl_new1(&tlv320_mixer_linein, chip));
1772+ if (err)
1773+ goto error;
1774+ err = snd_ctl_add(chip->card,
1775+ snd_ctl_new1(&tlv320_mixer_capture_source,
1776+ chip));
1777+ if (err)
1778+ goto error;
1779+ err = snd_ctl_add(chip->card,
1780+ snd_ctl_new1(&tlv320_mixer_mic_boost,
1781+ chip));
1782+ if (err)
1783+ goto error;
1784+ g_mastervol = TLV320A_VOL_INIT;
1785+ g_lineinvol = TLV320A_LINEIN_INIT;
1786+ g_analogpath = TLV320A_ANALOGPATH_INIT;
1787+ ssi_audio_codec_reset();
1788+ return 0;
1789+error:
1790+ kfree(card->private_data);
1791+ snd_card_free(card);
1792+ platform_set_drvdata(dev, NULL);
1793+ return err;
1794+}
1795+
1796+static int coldfire_alsa_audio_remove(struct platform_device *dev)
1797+{
1798+ struct snd_card *card;
1799+
1800+ card = platform_get_drvdata(dev);
1801+ kfree(card->private_data);
1802+ snd_card_free(card);
1803+ platform_set_drvdata(dev, NULL);
1804+
1805+ return 0;
1806+}
1807+
1808+static struct platform_driver coldfire_alsa_audio_driver = {
1809+ .probe = coldfire_alsa_audio_probe,
1810+ .remove = coldfire_alsa_audio_remove,
1811+ .driver = {
1812+ .name = SOUND_CARD_NAME,
1813+ },
1814+};
1815+
1816+static int __init coldfire_alsa_audio_init(void)
1817+{
1818+ int err;
1819+ err = platform_driver_register(&coldfire_alsa_audio_driver);
1820+ if (err < 0)
1821+ return err;
1822+
1823+ device = platform_device_register_simple(SOUND_CARD_NAME, -1, NULL, 0);
1824+ if (!IS_ERR(device)) {
1825+ if (platform_get_drvdata(device))
1826+ return 0;
1827+ platform_device_unregister(device);
1828+ platform_driver_unregister(&coldfire_alsa_audio_driver);
1829+ err = -ENODEV;
1830+ } else
1831+ err = PTR_ERR(device);
1832+
1833+ platform_driver_unregister(&coldfire_alsa_audio_driver);
1834+ return err;
1835+}
1836+
1837+static void __exit coldfire_alsa_audio_exit(void)
1838+{
1839+ platform_device_unregister(device);
1840+ platform_driver_unregister(&coldfire_alsa_audio_driver);
1841+}
1842+
1843+module_init(coldfire_alsa_audio_init);
1844+module_exit(coldfire_alsa_audio_exit);
1845+
1846+MODULE_DESCRIPTION("Coldfire driver for ALSA");
1847+MODULE_LICENSE("GPL");
1848+MODULE_SUPPORTED_DEVICE("{{TLV320A}}");
1849+
1850+module_param(id, charp, 0444);
1851+MODULE_PARM_DESC(id, "ID string for Coldfire + TLV320A soundcard.");
1852--- /dev/null
1853+++ b/sound/coldfire/snd-coldfire.h
1854@@ -0,0 +1,15 @@
1855+/*
1856+ * linux/sound/coldfire/snd-coldfire.h
1857+ *
1858+ * Copyright (C) 2008-2011 Freescale Semiconductor, Inc. All Rights Reserved.
1859+ *
1860+ * ALSA driver for Coldfire SSI
1861+ *
1862+ * This is free software; you can redistribute it and/or modify
1863+ * it under the terms of the GNU General Public License as published by
1864+ * the Free Software Foundation; either version 2 of the License, or
1865+ * (at your option) any later version.
1866+ */
1867+
1868+extern int mcf_codec_spi_write(u8 addr, u16 data);
1869+
1870

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive