sound/arm/omap/omap-alsa-dma.c

   1 /*
   2  * sound/arm/omap/omap-alsa-dma.c
   3  *
   4  * Common audio DMA handling for the OMAP processors
   5  *
   6  * Copyright (C) 2006 Mika Laitio <lamikr@cc.jyu.fi>
   7  *
   8  * Copyright (C) 2005 Instituto Nokia de Tecnologia - INdT - Manaus Brazil
   9  *
  10  * Copyright (C) 2004 Texas Instruments, Inc.
  11  *
  12  * Copyright (C) 2000, 2001 Nicolas Pitre <nico@cam.org>
  13  *
  14  * This package is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License version 2 as
  16  * published by the Free Software Foundation.
  17  *
  18  * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  20  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  21  *
  22  * History:
  23  *
  24  * 2004-06-07   Sriram Kannan   - Created new file from omap_audio_dma_intfc.c.
  25  *                              This file will contain only the DMA interface
  26  *                              and buffer handling of OMAP audio driver.
  27  *
  28  * 2004-06-22   Sriram Kannan   - removed legacy code (auto-init). Self-linking
  29  *                              of DMA logical channel.
  30  *
  31  * 2004-08-12   Nishanth Menon  - Modified to integrate Audio requirements on
  32  *                              1610, 1710 platforms
  33  *
  34  * 2004-11-01   Nishanth Menon  - 16xx platform code base modified to support
  35  *                              multi channel chaining.
  36  *
  37  * 2004-12-15   Nishanth Menon  - Improved 16xx platform channel logic
  38  *                              introduced - tasklets, queue handling updated
  39  *
  40  * 2005-07-19   INdT Kernel Team - Alsa port. Creation of new file
  41  *                              omap-alsa-dma.c based in omap-audio-dma-intfc.c
  42  *                              oss file. Support for aic23 codec. Removal of
  43  *                              buffer handling (Alsa does that), modifications
  44  *                              in dma handling and port to alsa structures.
  45  *
  46  * 2005-12-18   Dirk Behme      - Added L/R Channel Interchange fix as proposed
  47  *                              by Ajaya Babu
  48  */
  49
  50 #include <linux/module.h>
  51 #include <linux/init.h>
  52 #include <linux/types.h>
  53 #include <linux/fs.h>
  54 #include <linux/mm.h>
  55 #include <linux/slab.h>
  56 #include <linux/sched.h>
  57 #include <linux/poll.h>
  58 #include <linux/pm.h>
  59 #include <linux/errno.h>
  60 #include <linux/sound.h>
  61 #include <linux/soundcard.h>
  62 #include <linux/sysrq.h>
  63 #include <linux/interrupt.h>
  64 #include <linux/dma-mapping.h>
  65 #include <linux/io.h>
  66 #include <linux/uaccess.h>
  67
  68 #include <asm/hardware.h>
  69 #include <asm/semaphore.h>
  70 #include <asm/arch/dma.h>
  71 #include <asm/arch/mcbsp.h>
  72 #include <asm/arch/omap-alsa.h>
  73
  74 #include "omap-alsa-dma.h"
  75
  76 #undef DEBUG
  77
  78 /*
  79  * Channel Queue Handling macros
  80  * tail always points to the current free entry
  81  * Head always points to the current entry being used
  82  * end is either head or tail
  83  */
  84
  85 #define AUDIO_QUEUE_INIT(s) s->dma_q_head = s->dma_q_tail = s->dma_q_count = 0;
  86 #define AUDIO_QUEUE_FULL(s) (nr_linked_channels == s->dma_q_count)
  87 #define AUDIO_QUEUE_LAST(s) (1 == s->dma_q_count)
  88 #define AUDIO_QUEUE_EMPTY(s) (0 == s->dma_q_count)
  89 #define __AUDIO_INCREMENT_QUEUE(end) ((end) = ((end)+1) % nr_linked_channels)
  90 #define AUDIO_INCREMENT_HEAD(s)                         \
  91         do {                                            \
  92                 __AUDIO_INCREMENT_QUEUE(s->dma_q_head); \
  93                 s->dma_q_count--;                       \
  94         } while (0)
  95 #define AUDIO_INCREMENT_TAIL(s)                         \
  96         do {                                            \
  97                 __AUDIO_INCREMENT_QUEUE(s->dma_q_tail); \
  98                 s->dma_q_count++;                       \
  99         } while (0)
 100
 101 /* DMA buffer fragmentation sizes */
 102 #define MAX_DMA_SIZE             0x1000000 /* todo: sync with alsa */
 103 /* #define CUT_DMA_SIZE          0x1000 */
 104 /* TODO: To be moved to more appropriate location */
 105 #define DCSR_ERROR           0x3
 106 #define DCSR_END_BLOCK       (1 << 5)
 107 #define DCSR_SYNC_SET        (1 << 6)
 108
 109 #define DCCR_FS              (1 << 5)
 110 #define DCCR_PRIO            (1 << 6)
 111 #define DCCR_AI              (1 << 8)
 112 #define DCCR_REPEAT          (1 << 9)
 113 /* if 0 the channel works in 3.1 compatible mode */
 114 #define DCCR_N31COMP         (1 << 10)
 115 #define DCCR_EP              (1 << 11)
 116 #define DCCR_SRC_AMODE_BIT   12
 117 #define DCCR_SRC_AMODE_MASK  (0x3<<12)
 118 #define DCCR_DST_AMODE_BIT   14
 119 #define DCCR_DST_AMODE_MASK  (0x3<<14)
 120 #define AMODE_CONST          0x0
 121 #define AMODE_POST_INC       0x1
 122 #define AMODE_SINGLE_INDEX   0x2
 123 #define AMODE_DOUBLE_INDEX   0x3
 124
 125 /* Data structures */
 126 DEFINE_SPINLOCK(dma_list_lock);
 127 static char nr_linked_channels = 1;
 128
 129 /* Module specific functions */
 130
 131 static void sound_dma_irq_handler(int lch, u16 ch_status, void *data);
 132 static int audio_set_dma_params_play(int channel, dma_addr_t dma_ptr,
 133                                      u_int dma_size);
 134 static int audio_set_dma_params_capture(int channel, dma_addr_t dma_ptr,
 135                                         u_int dma_size);
 136 static int audio_start_dma_chain(struct audio_stream *s);
 137
 138 /*
 139  * DMA channel requests
 140  */
 141 static void omap_sound_dma_link_lch(void *data)
 142 {
 143
 144         struct audio_stream *s = (struct audio_stream *) data;
 145         int *chan = s->lch;
 146         int i;
 147
 148         FN_IN;
 149         if (s->linked) {
 150                 FN_OUT(1);
 151                 return;
 152         }
 153         for (i = 0; i < nr_linked_channels; i++) {
 154                 int cur_chan = chan[i];
 155                 int nex_chan =
 156                     ((nr_linked_channels - 1 ==
 157                       i) ? chan[0] : chan[i + 1]);
 158                 omap_dma_link_lch(cur_chan, nex_chan);
 159         }
 160         s->linked = 1;
 161         FN_OUT(0);
 162 }
 163
 164 int omap_request_alsa_sound_dma(int device_id, const char *device_name,
 165                            void *data, int **channels)
 166 {
 167         int i, err = 0;
 168         int *chan = NULL;
 169         FN_IN;
 170         if (unlikely((NULL == channels) || (NULL == device_name))) {
 171                 BUG();
 172                 return -EPERM;
 173         }
 174         /* Try allocate memory for the num channels */
 175         *channels = kmalloc(sizeof(int) * nr_linked_channels, GFP_KERNEL);
 176         chan = *channels;
 177         if (NULL == chan) {
 178                 ERR("No Memory for channel allocs!\n");
 179                 FN_OUT(-ENOMEM);
 180                 return -ENOMEM;
 181         }
 182         spin_lock(&dma_list_lock);
 183         for (i = 0; i < nr_linked_channels; i++) {
 184                 err = omap_request_dma(device_id,
 185                                 device_name,
 186                                 sound_dma_irq_handler,
 187                                 data,
 188                                 &chan[i]);
 189
 190                 /* Handle Failure condition here */
 191                 if (err < 0) {
 192                         int j;
 193
 194                         for (j = 0; j < i; j++)
 195                                 omap_free_dma(chan[j]);
 196
 197                         spin_unlock(&dma_list_lock);
 198                         kfree(chan);
 199                         *channels = NULL;
 200                         ERR("Error in requesting channel %d=0x%x\n", i,
 201                             err);
 202                         FN_OUT(err);
 203                         return err;
 204                 }
 205         }
 206
 207         /* Chain the channels together */
 208         if (!cpu_is_omap15xx())
 209                 omap_sound_dma_link_lch(data);
 210
 211         spin_unlock(&dma_list_lock);
 212         FN_OUT(0);
 213         return 0;
 214 }
 215 EXPORT_SYMBOL(omap_request_alsa_sound_dma);
 216
 217 /*
 218  * DMA channel requests Freeing
 219  */
 220 static void omap_sound_dma_unlink_lch(void *data)
 221 {
 222         struct audio_stream *s = (struct audio_stream *)data;
 223         int *chan = s->lch;
 224         int i;
 225
 226         FN_IN;
 227         if (!s->linked) {
 228                 FN_OUT(1);
 229                 return;
 230         }
 231         for (i = 0; i < nr_linked_channels; i++) {
 232                 int cur_chan = chan[i];
 233                 int nex_chan =
 234                     ((nr_linked_channels - 1 ==
 235                       i) ? chan[0] : chan[i + 1]);
 236                 omap_dma_unlink_lch(cur_chan, nex_chan);
 237         }
 238         s->linked = 0;
 239         FN_OUT(0);
 240 }
 241
 242 int omap_free_alsa_sound_dma(void *data, int **channels)
 243 {
 244         int i;
 245         int *chan = NULL;
 246
 247         FN_IN;
 248         if (unlikely(NULL == channels)) {
 249                 BUG();
 250                 return -EPERM;
 251         }
 252         if (unlikely(NULL == *channels)) {
 253                 BUG();
 254                 return -EPERM;
 255         }
 256         chan = (*channels);
 257
 258         if (!cpu_is_omap15xx())
 259                 omap_sound_dma_unlink_lch(data);
 260         for (i = 0; i < nr_linked_channels; i++) {
 261                 int cur_chan = chan[i];
 262                 omap_stop_dma(cur_chan);
 263                 omap_free_dma(cur_chan);
 264         }
 265         kfree(*channels);
 266         *channels = NULL;
 267         FN_OUT(0);
 268         return 0;
 269 }
 270 EXPORT_SYMBOL(omap_free_alsa_sound_dma);
 271
 272 /*
 273  * Stop all the DMA channels of the stream
 274  */
 275 void omap_stop_alsa_sound_dma(struct audio_stream *s)
 276 {
 277         int *chan = s->lch;
 278         int i;
 279
 280         FN_IN;
 281         if (unlikely(NULL == chan)) {
 282                 BUG();
 283                 return;
 284         }
 285         for (i = 0; i < nr_linked_channels; i++) {
 286                 int cur_chan = chan[i];
 287                 omap_stop_dma(cur_chan);
 288         }
 289         s->started = 0;
 290         FN_OUT(0);
 291         return;
 292 }
 293 EXPORT_SYMBOL(omap_stop_alsa_sound_dma);
 294
 295 /*
 296  * Clear any pending transfers
 297  */
 298 void omap_clear_alsa_sound_dma(struct audio_stream *s)
 299 {
 300         FN_IN;
 301         omap_clear_dma(s->lch[s->dma_q_head]);
 302         FN_OUT(0);
 303         return;
 304 }
 305 EXPORT_SYMBOL(omap_clear_alsa_sound_dma);
 306
 307 /*
 308  * DMA related functions
 309  */
 310 static int audio_set_dma_params_play(int channel, dma_addr_t dma_ptr,
 311                                      u_int dma_size)
 312 {
 313         int dt = 0x1;           /* data type 16 */
 314         int cen = 32;           /* Stereo */
 315         int cfn = dma_size / (2 * cen);
 316
 317         FN_IN;
 318         omap_set_dma_dest_params(channel, 0x05, 0x00,
 319                                  (OMAP1510_MCBSP1_BASE + 0x06),
 320                                  0, 0);
 321         omap_set_dma_src_params(channel, 0x00, 0x01, dma_ptr,
 322                                 0, 0);
 323         omap_set_dma_transfer_params(channel, dt, cen, cfn, 0x00, 0, 0);
 324         FN_OUT(0);
 325         return 0;
 326 }
 327
 328 static int audio_set_dma_params_capture(int channel, dma_addr_t dma_ptr,
 329                                         u_int dma_size)
 330 {
 331         int dt = 0x1;           /* data type 16 */
 332         int cen = 32;           /* stereo */
 333         int cfn = dma_size / (2 * cen);
 334
 335         FN_IN;
 336         omap_set_dma_src_params(channel, 0x05, 0x00,
 337                                 (OMAP1510_MCBSP1_BASE + 0x02),
 338                                 0, 0);
 339         omap_set_dma_dest_params(channel, 0x00, 0x01, dma_ptr, 0, 0);
 340         omap_set_dma_transfer_params(channel, dt, cen, cfn, 0x00, 0, 0);
 341         FN_OUT(0);
 342         return 0;
 343 }
 344
 345 static int audio_start_dma_chain(struct audio_stream *s)
 346 {
 347         int channel = s->lch[s->dma_q_head];
 348         FN_IN;
 349         if (!s->started) {
 350                 s->hw_stop();      /* stops McBSP Interface */
 351                 omap_start_dma(channel);
 352                 s->started = 1;
 353                 s->hw_start();     /* start McBSP interface */
 354         } else if (cpu_is_omap310())
 355                 omap_start_dma(channel);
 356         /* else the dma itself will progress forward with out our help */
 357         FN_OUT(0);
 358         return 0;
 359 }
 360
 361 /*
 362  * Start DMA -
 363  * Do the initial set of work to initialize all the channels as required.
 364  * We shall then initate a transfer
 365  */
 366 int omap_start_alsa_sound_dma(struct audio_stream *s,
 367                         dma_addr_t dma_ptr,
 368                         u_int dma_size)
 369 {
 370         int ret = -EPERM;
 371
 372         FN_IN;
 373
 374         if (unlikely(dma_size > MAX_DMA_SIZE)) {
 375                 ERR("DmaSoundDma: Start: overflowed %d-%d\n", dma_size,
 376                     MAX_DMA_SIZE);
 377                 return -EOVERFLOW;
 378         }
 379
 380         if (s->stream_id == SNDRV_PCM_STREAM_PLAYBACK) {
 381                 /* playback */
 382                 ret =
 383                     audio_set_dma_params_play(s->lch[s->dma_q_tail],
 384                                               dma_ptr, dma_size);
 385         } else {
 386                 ret =
 387                     audio_set_dma_params_capture(s->lch[s->dma_q_tail],
 388                                                  dma_ptr, dma_size);
 389         }
 390         if (ret != 0) {
 391                 ret = -3;       /* indicate queue full */
 392                 goto sound_out;
 393         }
 394         AUDIO_INCREMENT_TAIL(s);
 395         ret = audio_start_dma_chain(s);
 396         if (ret)
 397                 ERR("dma start failed");
 398
 399 sound_out:
 400         FN_OUT(ret);
 401         return ret;
 402
 403 }
 404 EXPORT_SYMBOL(omap_start_alsa_sound_dma);
 405
 406 /*
 407  * ISRs have to be short and smart..
 408  * Here we call alsa handling, after some error checking
 409  */
 410 static void sound_dma_irq_handler(int sound_curr_lch, u16 ch_status,
 411                                   void *data)
 412 {
 413         int dma_status = ch_status;
 414         struct audio_stream *s = (struct audio_stream *) data;
 415         FN_IN;
 416
 417         /* some register checking */
 418         DPRINTK("lch=%d,status=0x%x, dma_status=%d, data=%p\n",
 419                 sound_curr_lch, ch_status, dma_status, data);
 420
 421         if (dma_status & (DCSR_ERROR)) {
 422                 omap_stop_dma(sound_curr_lch);
 423                 ERR("DCSR_ERROR!\n");
 424                 FN_OUT(-1);
 425                 return;
 426         }
 427
 428         if (ch_status & DCSR_END_BLOCK)
 429                 callback_omap_alsa_sound_dma(s);
 430         FN_OUT(0);
 431         return;
 432 }
 433
 434 MODULE_AUTHOR("Texas Instruments");
 435 MODULE_DESCRIPTION("Common DMA handling for Audio driver on OMAP processors");
 436 MODULE_LICENSE("GPL");
 437