sound/arm/omap/omap-alsa.c

   1 /*
   2  * sound/arm/omap-alsa.c
   3  *
   4  * Alsa Driver for OMAP
   5  *
   6  * Copyright (C) 2005 Instituto Nokia de Tecnologia - INdT - Manaus Brazil
   7  * Written by Daniel Petrini, David Cohen, Anderson Briglia
   8  *            {daniel.petrini, david.cohen, anderson.briglia}@indt.org.br
   9  *
  10  * Copyright (C) 2006 Mika Laitio <lamikr@cc.jyu.fi>
  11  *
  12  * Based on sa11xx-uda1341.c,
  13  * Copyright (C) 2002 Tomas Kasparek <tomas.kasparek@seznam.cz>
  14  *
  15  * This program is free software; you can redistribute it and/or modify it
  16  * under the terms of the GNU General Public License as published by the
  17  * Free Software Foundation; either version 2 of the License, or (at your
  18  * option) any later version.
  19  *
  20  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  21  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  22  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
  23  * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  26  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  27  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  *
  31  * You should have received a copy of the  GNU General Public License along
  32  * with this program; if not, write  to the Free Software Foundation, Inc.,
  33  * 675 Mass Ave, Cambridge, MA 02139, USA.
  34  *
  35  * History:
  36  *
  37  * 2005-07-29   INdT Kernel Team - Alsa driver for omap osk. Creation of new
  38  *                                 file omap-aic23.c
  39  *
  40  * 2005-12-18   Dirk Behme       - Added L/R Channel Interchange fix as proposed
  41  *                                 by Ajaya Babu
  42  *
  43  */
  44
  45 #include <linux/platform_device.h>
  46 #ifdef CONFIG_PM
  47 #include <linux/pm.h>
  48 #endif
  49 #include <sound/driver.h>
  50 #include <sound/core.h>
  51
  52 #include <asm/arch/omap-alsa.h>
  53 #include "omap-alsa-dma.h"
  54
  55 MODULE_AUTHOR("Mika Laitio, Daniel Petrini, David Cohen, Anderson Briglia - INdT");
  56 MODULE_LICENSE("GPL");
  57 MODULE_DESCRIPTION("OMAP driver for ALSA");
  58 MODULE_ALIAS("omap_alsa_mcbsp.1");
  59
  60 static char *id = NULL;
  61 static struct snd_card_omap_codec       *alsa_codec             = NULL;
  62 static struct omap_alsa_codec_config    *alsa_codec_config      = NULL;
  63
  64 /*
  65  * HW interface start and stop helper functions
  66  */
  67 static int audio_ifc_start(void)
  68 {
  69         omap_mcbsp_start(AUDIO_MCBSP);
  70         return 0;
  71 }
  72
  73 static int audio_ifc_stop(void)
  74 {
  75         omap_mcbsp_stop(AUDIO_MCBSP);
  76         return 0;
  77 }
  78
  79 static void omap_alsa_audio_init(struct snd_card_omap_codec *omap_alsa)
  80 {
  81         /* Setup DMA stuff */
  82         omap_alsa->s[SNDRV_PCM_STREAM_PLAYBACK].id = "Alsa omap out";
  83         omap_alsa->s[SNDRV_PCM_STREAM_PLAYBACK].stream_id =
  84             SNDRV_PCM_STREAM_PLAYBACK;
  85         omap_alsa->s[SNDRV_PCM_STREAM_PLAYBACK].dma_dev =
  86             OMAP_DMA_MCBSP1_TX;
  87         omap_alsa->s[SNDRV_PCM_STREAM_PLAYBACK].hw_start =
  88             audio_ifc_start;
  89         omap_alsa->s[SNDRV_PCM_STREAM_PLAYBACK].hw_stop =
  90             audio_ifc_stop;
  91
  92         omap_alsa->s[SNDRV_PCM_STREAM_CAPTURE].id = "Alsa omap in";
  93         omap_alsa->s[SNDRV_PCM_STREAM_CAPTURE].stream_id =
  94             SNDRV_PCM_STREAM_CAPTURE;
  95         omap_alsa->s[SNDRV_PCM_STREAM_CAPTURE].dma_dev =
  96             OMAP_DMA_MCBSP1_RX;
  97         omap_alsa->s[SNDRV_PCM_STREAM_CAPTURE].hw_start =
  98             audio_ifc_start;
  99         omap_alsa->s[SNDRV_PCM_STREAM_CAPTURE].hw_stop =
 100             audio_ifc_stop;
 101 }
 102
 103 /*
 104  * DMA functions
 105  * Depends on omap-alsa-dma.c functions and (omap) dma.c
 106  *
 107  */
 108 static int audio_dma_request(struct audio_stream *s,
 109                              void (*callback) (void *))
 110 {
 111         int err;
 112         ADEBUG();
 113
 114         err = omap_request_alsa_sound_dma(s->dma_dev, s->id, s, &s->lch);
 115         if (err < 0)
 116                 printk(KERN_ERR "Unable to grab audio dma 0x%x\n", s->dma_dev);
 117         return err;
 118 }
 119
 120 static int audio_dma_free(struct audio_stream *s)
 121 {
 122         int err = 0;
 123         ADEBUG();
 124
 125         err = omap_free_alsa_sound_dma(s, &s->lch);
 126         if (err < 0)
 127                 printk(KERN_ERR "Unable to free audio dma channels!\n");
 128         return err;
 129 }
 130
 131 /*
 132  *  This function should calculate the current position of the dma in the
 133  *  buffer. It will help alsa middle layer to continue update the buffer.
 134  *  Its correctness is crucial for good functioning.
 135  */
 136 static u_int audio_get_dma_pos(struct audio_stream *s)
 137 {
 138         snd_pcm_substream_t *substream = s->stream;
 139         snd_pcm_runtime_t *runtime = substream->runtime;
 140         unsigned int offset;
 141         unsigned long flags;
 142         dma_addr_t count;
 143         ADEBUG();
 144
 145         /* this must be called w/ interrupts locked as requested in dma.c */
 146         spin_lock_irqsave(&s->dma_lock, flags);
 147
 148         /* For the current period let's see where we are */
 149         count = omap_get_dma_src_addr_counter(s->lch[s->dma_q_head]);
 150
 151         spin_unlock_irqrestore(&s->dma_lock, flags);
 152
 153         /* Now, the position related to the end of that period */
 154         offset = bytes_to_frames(runtime, s->offset) - bytes_to_frames(runtime, count);
 155
 156         if (offset >= runtime->buffer_size)
 157                 offset = 0;
 158
 159         return offset;
 160 }
 161
 162 /*
 163  * this stops the dma and clears the dma ptrs
 164  */
 165 static void audio_stop_dma(struct audio_stream *s)
 166 {
 167         unsigned long flags;
 168         ADEBUG();
 169
 170         spin_lock_irqsave(&s->dma_lock, flags);
 171         s->active = 0;
 172         s->period = 0;
 173         s->periods = 0;
 174
 175         /* this stops the dma channel and clears the buffer ptrs */
 176         omap_stop_alsa_sound_dma(s);
 177
 178         omap_clear_alsa_sound_dma(s);
 179
 180         spin_unlock_irqrestore(&s->dma_lock, flags);
 181 }
 182
 183 /*
 184  *  Main dma routine, requests dma according where you are in main alsa buffer
 185  */
 186 static void audio_process_dma(struct audio_stream *s)
 187 {
 188         snd_pcm_substream_t *substream = s->stream;
 189         snd_pcm_runtime_t *runtime;
 190         unsigned int dma_size;
 191         unsigned int offset;
 192         int ret;
 193
 194         ADEBUG();
 195         runtime = substream->runtime;
 196         if (s->active) {
 197                 dma_size = frames_to_bytes(runtime, runtime->period_size);
 198                 offset = dma_size * s->period;
 199                 snd_assert(dma_size <= DMA_BUF_SIZE,);
 200                 /*
 201                  * On omap1510 based devices, we need to call the stop_dma
 202                  * before calling the start_dma or we will not receive the
 203                  * irq from DMA after the first transfered/played buffer.
 204                  * (invocation of callback_omap_alsa_sound_dma() method).
 205                  */
 206                 if (cpu_is_omap15xx()) {
 207                         omap_stop_alsa_sound_dma(s);
 208                 }
 209                 ret = omap_start_alsa_sound_dma(s,
 210                                 (dma_addr_t)runtime->dma_area + offset,
 211                                 dma_size);
 212                 if (ret) {
 213                         printk(KERN_ERR
 214                                "audio_process_dma: cannot queue DMA buffer (%i)\n",
 215                                ret);
 216                         return;
 217                 }
 218
 219                 s->period++;
 220                 s->period %= runtime->periods;
 221                 s->periods++;
 222                 s->offset = offset;
 223         }
 224 }
 225
 226 /*
 227  *  This is called when dma IRQ occurs at the end of each transmited block
 228  */
 229 void callback_omap_alsa_sound_dma(void *data)
 230 {
 231         struct audio_stream *s = data;
 232
 233         ADEBUG();
 234         /*
 235          * If we are getting a callback for an active stream then we inform
 236          * the PCM middle layer we've finished a period
 237          */
 238         if (s->active)
 239                 snd_pcm_period_elapsed(s->stream);
 240
 241         spin_lock(&s->dma_lock);
 242         if (s->periods > 0)
 243                 s->periods--;
 244
 245         audio_process_dma(s);
 246         spin_unlock(&s->dma_lock);
 247 }
 248
 249 /*
 250  * Alsa section
 251  * PCM settings and callbacks
 252  */
 253 static int snd_omap_alsa_trigger(snd_pcm_substream_t * substream, int cmd)
 254 {
 255         struct snd_card_omap_codec *chip =
 256             snd_pcm_substream_chip(substream);
 257         int stream_id = substream->pstr->stream;
 258         struct audio_stream *s = &chip->s[stream_id];
 259         int err = 0;
 260
 261         ADEBUG();
 262         /* note local interrupts are already disabled in the midlevel code */
 263         spin_lock(&s->dma_lock);
 264         switch (cmd) {
 265         case SNDRV_PCM_TRIGGER_START:
 266                 /* requested stream startup */
 267                 s->active = 1;
 268                 audio_process_dma(s);
 269                 break;
 270         case SNDRV_PCM_TRIGGER_STOP:
 271                 /* requested stream shutdown */
 272                 audio_stop_dma(s);
 273                 break;
 274         default:
 275                 err = -EINVAL;
 276                 break;
 277         }
 278         spin_unlock(&s->dma_lock);
 279
 280         return err;
 281 }
 282
 283 static int snd_omap_alsa_prepare(snd_pcm_substream_t * substream)
 284 {
 285         struct snd_card_omap_codec *chip = snd_pcm_substream_chip(substream);
 286         snd_pcm_runtime_t *runtime = substream->runtime;
 287         struct audio_stream *s = &chip->s[substream->pstr->stream];
 288
 289         ADEBUG();
 290         /* set requested samplerate */
 291         alsa_codec_config->codec_set_samplerate(runtime->rate);
 292         chip->samplerate = runtime->rate;
 293
 294         s->period = 0;
 295         s->periods = 0;
 296
 297         return 0;
 298 }
 299
 300 static snd_pcm_uframes_t snd_omap_alsa_pointer(snd_pcm_substream_t *substream)
 301 {
 302         struct snd_card_omap_codec *chip = snd_pcm_substream_chip(substream);
 303
 304         ADEBUG();
 305         return audio_get_dma_pos(&chip->s[substream->pstr->stream]);
 306 }
 307
 308 static int snd_card_omap_alsa_open(snd_pcm_substream_t * substream)
 309 {
 310         struct snd_card_omap_codec *chip =
 311             snd_pcm_substream_chip(substream);
 312         snd_pcm_runtime_t *runtime = substream->runtime;
 313         int stream_id = substream->pstr->stream;
 314         int err;
 315
 316         ADEBUG();
 317         chip->s[stream_id].stream = substream;
 318         alsa_codec_config->codec_clock_on();
 319         if (stream_id == SNDRV_PCM_STREAM_PLAYBACK)
 320                 runtime->hw = *(alsa_codec_config->snd_omap_alsa_playback);
 321         else
 322                 runtime->hw = *(alsa_codec_config->snd_omap_alsa_capture);
 323
 324         if ((err = snd_pcm_hw_constraint_integer(runtime,
 325                                            SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
 326                 return err;
 327
 328         if ((err = snd_pcm_hw_constraint_list(runtime,
 329                                         0,
 330                                         SNDRV_PCM_HW_PARAM_RATE,
 331                                         alsa_codec_config->hw_constraints_rates)) < 0)
 332                 return err;
 333
 334         return 0;
 335 }
 336
 337 static int snd_card_omap_alsa_close(snd_pcm_substream_t * substream)
 338 {
 339         struct snd_card_omap_codec *chip = snd_pcm_substream_chip(substream);
 340
 341         ADEBUG();
 342         alsa_codec_config->codec_clock_off();
 343         chip->s[substream->pstr->stream].stream = NULL;
 344
 345         return 0;
 346 }
 347
 348 /* HW params & free */
 349 static int snd_omap_alsa_hw_params(snd_pcm_substream_t * substream,
 350                                     snd_pcm_hw_params_t * hw_params)
 351 {
 352         return snd_pcm_lib_malloc_pages(substream,
 353                                         params_buffer_bytes(hw_params));
 354 }
 355
 356 static int snd_omap_alsa_hw_free(snd_pcm_substream_t * substream)
 357 {
 358         return snd_pcm_lib_free_pages(substream);
 359 }
 360
 361 /* pcm operations */
 362 static snd_pcm_ops_t snd_card_omap_alsa_playback_ops = {
 363         .open =         snd_card_omap_alsa_open,
 364         .close =        snd_card_omap_alsa_close,
 365         .ioctl =        snd_pcm_lib_ioctl,
 366         .hw_params =    snd_omap_alsa_hw_params,
 367         .hw_free =      snd_omap_alsa_hw_free,
 368         .prepare =      snd_omap_alsa_prepare,
 369         .trigger =      snd_omap_alsa_trigger,
 370         .pointer =      snd_omap_alsa_pointer,
 371 };
 372
 373 static snd_pcm_ops_t snd_card_omap_alsa_capture_ops = {
 374         .open =         snd_card_omap_alsa_open,
 375         .close =        snd_card_omap_alsa_close,
 376         .ioctl =        snd_pcm_lib_ioctl,
 377         .hw_params =    snd_omap_alsa_hw_params,
 378         .hw_free =      snd_omap_alsa_hw_free,
 379         .prepare =      snd_omap_alsa_prepare,
 380         .trigger =      snd_omap_alsa_trigger,
 381         .pointer =      snd_omap_alsa_pointer,
 382 };
 383
 384 /*
 385  *  Alsa init and exit section
 386  *
 387  *  Inits pcm alsa structures, allocate the alsa buffer, suspend, resume
 388  */
 389 static int __init snd_card_omap_alsa_pcm(struct snd_card_omap_codec *omap_alsa,
 390                                         int device)
 391 {
 392         snd_pcm_t *pcm;
 393         int err;
 394
 395         ADEBUG();
 396         if ((err = snd_pcm_new(omap_alsa->card, "OMAP PCM", device, 1, 1, &pcm)) < 0)
 397                 return err;
 398
 399         /* sets up initial buffer with continuous allocation */
 400         snd_pcm_lib_preallocate_pages_for_all(pcm,
 401                                               SNDRV_DMA_TYPE_CONTINUOUS,
 402                                               snd_dma_continuous_data
 403                                               (GFP_KERNEL),
 404                                               128 * 1024, 128 * 1024);
 405
 406         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
 407                         &snd_card_omap_alsa_playback_ops);
 408         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
 409                         &snd_card_omap_alsa_capture_ops);
 410         pcm->private_data = omap_alsa;
 411         pcm->info_flags = 0;
 412         strcpy(pcm->name, "omap alsa pcm");
 413
 414         omap_alsa_audio_init(omap_alsa);
 415
 416         /* setup DMA controller */
 417         audio_dma_request(&omap_alsa->s[SNDRV_PCM_STREAM_PLAYBACK],
 418                           callback_omap_alsa_sound_dma);
 419         audio_dma_request(&omap_alsa->s[SNDRV_PCM_STREAM_CAPTURE],
 420                           callback_omap_alsa_sound_dma);
 421
 422         omap_alsa->pcm = pcm;
 423
 424         return 0;
 425 }
 426
 427
 428 #ifdef CONFIG_PM
 429 /*
 430  * Driver suspend/resume - calls alsa functions. Some hints from aaci.c
 431  */
 432 int snd_omap_alsa_suspend(struct platform_device *pdev, pm_message_t state)
 433 {
 434         struct snd_card_omap_codec *chip;
 435         snd_card_t *card = platform_get_drvdata(pdev);
 436
 437         if (card->power_state != SNDRV_CTL_POWER_D3hot) {
 438                 chip = card->private_data;
 439                 if (chip->card->power_state != SNDRV_CTL_POWER_D3hot) {
 440                         snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot);
 441                         snd_pcm_suspend_all(chip->pcm);
 442                         /* Mutes and turn clock off */
 443                         alsa_codec_config->codec_clock_off();
 444                         snd_omap_suspend_mixer();
 445                 }
 446         }
 447         return 0;
 448 }
 449
 450 int snd_omap_alsa_resume(struct platform_device *pdev)
 451 {
 452         struct snd_card_omap_codec *chip;
 453         snd_card_t *card = platform_get_drvdata(pdev);
 454
 455         if (card->power_state != SNDRV_CTL_POWER_D0) {
 456                 chip = card->private_data;
 457                 if (chip->card->power_state != SNDRV_CTL_POWER_D0) {
 458                         snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0);
 459                         alsa_codec_config->codec_clock_on();
 460                         snd_omap_resume_mixer();
 461                 }
 462         }
 463         return 0;
 464 }
 465
 466 #endif  /* CONFIG_PM */
 467
 468 void snd_omap_alsa_free(snd_card_t * card)
 469 {
 470         struct snd_card_omap_codec *chip = card->private_data;
 471         ADEBUG();
 472
 473         /*
 474          * Turn off codec after it is done.
 475          * Can't do it immediately, since it may still have
 476          * buffered data.
 477          */
 478         schedule_timeout_interruptible(2);
 479
 480         omap_mcbsp_stop(AUDIO_MCBSP);
 481         omap_mcbsp_free(AUDIO_MCBSP);
 482
 483         audio_dma_free(&chip->s[SNDRV_PCM_STREAM_PLAYBACK]);
 484         audio_dma_free(&chip->s[SNDRV_PCM_STREAM_CAPTURE]);
 485 }
 486
 487 /* module init & exit */
 488
 489 /*
 490  * Inits alsa soudcard structure.
 491  * Called by the probe method in codec after function pointers has been set.
 492  */
 493 int snd_omap_alsa_post_probe(struct platform_device *pdev, struct omap_alsa_codec_config *config)
 494 {
 495         int err = 0;
 496         int def_rate;
 497         snd_card_t *card;
 498
 499         ADEBUG();
 500         alsa_codec_config       = config;
 501
 502         alsa_codec_config->codec_clock_setup();
 503         alsa_codec_config->codec_clock_on();
 504
 505         omap_mcbsp_request(AUDIO_MCBSP);
 506         omap_mcbsp_stop(AUDIO_MCBSP);
 507         omap_mcbsp_config(AUDIO_MCBSP, alsa_codec_config->mcbsp_regs_alsa);
 508         omap_mcbsp_start(AUDIO_MCBSP);
 509
 510         if (alsa_codec_config && alsa_codec_config->codec_configure_dev)
 511                 alsa_codec_config->codec_configure_dev();
 512
 513         alsa_codec_config->codec_clock_off();
 514
 515         /* register the soundcard */
 516         card = snd_card_new(-1, id, THIS_MODULE, sizeof(alsa_codec));
 517         if (card == NULL)
 518                 goto nodev1;
 519
 520         alsa_codec = kcalloc(1, sizeof(*alsa_codec), GFP_KERNEL);
 521         if (alsa_codec == NULL)
 522                 goto nodev2;
 523
 524         card->private_data = (void *)alsa_codec;
 525         card->private_free = snd_omap_alsa_free;
 526
 527         alsa_codec->card        = card;
 528         def_rate                = alsa_codec_config->get_default_samplerate();
 529         alsa_codec->samplerate  = def_rate;
 530
 531         spin_lock_init(&alsa_codec->s[0].dma_lock);
 532         spin_lock_init(&alsa_codec->s[1].dma_lock);
 533
 534         /* mixer */
 535         if ((err = snd_omap_mixer(alsa_codec)) < 0)
 536                 goto nodev3;
 537
 538         /* PCM */
 539         if ((err = snd_card_omap_alsa_pcm(alsa_codec, 0)) < 0)
 540                 goto nodev3;
 541
 542         strcpy(card->driver, "OMAP_ALSA");
 543         strcpy(card->shortname, alsa_codec_config->name);
 544         sprintf(card->longname, alsa_codec_config->name);
 545
 546         snd_omap_init_mixer();
 547         snd_card_set_dev(card, &pdev->dev);
 548
 549         if ((err = snd_card_register(card)) == 0) {
 550                 printk(KERN_INFO "audio support initialized\n");
 551                 platform_set_drvdata(pdev, card);
 552                 return 0;
 553         }
 554
 555 nodev3:
 556         kfree(alsa_codec);
 557 nodev2:
 558         snd_card_free(card);
 559 nodev1:
 560         omap_mcbsp_stop(AUDIO_MCBSP);
 561         omap_mcbsp_free(AUDIO_MCBSP);
 562
 563         return err;
 564 }
 565
 566 int snd_omap_alsa_remove(struct platform_device *pdev)
 567 {
 568         snd_card_t *card = platform_get_drvdata(pdev);
 569         struct snd_card_omap_codec *chip = card->private_data;
 570
 571         snd_card_free(card);
 572
 573         alsa_codec = NULL;
 574         card->private_data = NULL;
 575         kfree(chip);
 576
 577         platform_set_drvdata(pdev, NULL);
 578
 579         return 0;
 580 }