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

   1 From d37d2d880efdc0ce515df4155ddafef3835d1b7f Mon Sep 17 00:00:00 2001
   2 From: Alison Wang <b18965@freescale.com>
   3 Date: Thu, 4 Aug 2011 09:59:41 +0800
   4 Subject: [PATCH 09/52] Add ALSA driver for MCF5445x
   5
   6 Add ALSA driver for MCF54451 and MCF54455.
   7
   8 Signed-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 +