firmware/target/arm/as3525/pcm-as3525.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright © 2008-2009 Rafaël Carré
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include "system.h"
  22 #include "audio.h"
  23 #include "string.h"
  24 #include "as3525.h"
  25 #include "pl081.h"
  26 #include "dma-target.h"
  27 #include "clock-target.h"
  28 #include "panic.h"
  29 #include "as3514.h"
  30 #include "audiohw.h"
  31 #include "mmu-arm.h"
  32
  33 #define MAX_TRANSFER (4*((1<<11)-1)) /* maximum data we can transfer via DMA
  34                                       * i.e. 32 bits at once (size of I2SO_DATA)
  35                                       * and the number of 32bits words has to
  36                                       * fit in 11 bits of DMA register */
  37
  38 static void *dma_start_addr;
  39 static size_t      dma_size;   /* in 4*32 bits */
  40 static size_t      play_sub_size;  /* size of subtransfer */
  41 static void dma_callback(void);
  42 static int locked = 0;
  43 static bool is_playing = false;
  44 static bool play_callback_pending = false;
  45
  46 /* Mask the DMA interrupt */
  47 void pcm_play_lock(void)
  48 {
  49     ++locked;
  50 }
  51
  52 /* Unmask the DMA interrupt if enabled */
  53 void pcm_play_unlock(void)
  54 {
  55     if(--locked == 0 && is_playing)
  56     {
  57         int old = disable_irq_save();
  58         if(play_callback_pending)
  59         {
  60             play_callback_pending = false;
  61             dma_callback();
  62         }
  63         restore_irq(old);
  64     }
  65 }
  66
  67 static void play_start_pcm(void)
  68 {
  69     const unsigned char* addr = dma_start_addr;
  70     size_t size = dma_size;
  71     if(size > MAX_TRANSFER)
  72         size = MAX_TRANSFER;
  73
  74     play_sub_size = size;
  75
  76     clean_dcache_range((void*)addr, size);  /* force write back */
  77     dma_enable_channel(1, (void*)addr, (void*)I2SOUT_DATA, DMA_PERI_I2SOUT,
  78                 DMAC_FLOWCTRL_DMAC_MEM_TO_PERI, true, false, size >> 2, DMA_S1,
  79                 dma_callback);
  80 }
  81
  82 static void dma_callback(void)
  83 {
  84     dma_size -= play_sub_size;
  85     dma_start_addr += play_sub_size;
  86     play_sub_size = 0; /* Might get called again if locked */
  87
  88     if(locked)
  89     {
  90         play_callback_pending = is_playing;
  91         return;
  92     }
  93
  94     if(!dma_size)
  95     {
  96         pcm_play_get_more_callback(&dma_start_addr, &dma_size);
  97
  98         if (!dma_size)
  99             return;
 100     }
 101
 102     play_start_pcm();
 103 }
 104
 105 void pcm_play_dma_start(const void *addr, size_t size)
 106 {
 107     dma_size = size;
 108     dma_start_addr = (unsigned char*)addr;
 109
 110     bitset32(&CGU_PERI, CGU_I2SOUT_APB_CLOCK_ENABLE);
 111     CGU_AUDIO |= (1<<11);
 112
 113     dma_retain();
 114
 115     is_playing = true;
 116
 117     play_start_pcm();
 118 }
 119
 120 void pcm_play_dma_stop(void)
 121 {
 122     is_playing = false;
 123     dma_disable_channel(1);
 124     dma_size = 0;
 125
 126     dma_release();
 127
 128     bitclr32(&CGU_PERI, CGU_I2SOUT_APB_CLOCK_ENABLE);
 129     CGU_AUDIO &= ~(1<<11);
 130
 131     play_callback_pending = false;
 132 }
 133
 134 void pcm_play_dma_pause(bool pause)
 135 {
 136     if(pause)
 137     {
 138         is_playing = false;
 139         dma_disable_channel(1);
 140         play_callback_pending = false;
 141     }
 142     else
 143     {
 144         play_start_pcm();
 145     }
 146 }
 147
 148 void pcm_play_dma_init(void)
 149 {
 150     bitset32(&CGU_PERI, CGU_I2SOUT_APB_CLOCK_ENABLE);
 151
 152     I2SOUT_CONTROL = (1<<6)|(1<<3)  /* enable dma, stereo */;
 153
 154     audiohw_preinit();
 155 }
 156
 157 void pcm_postinit(void)
 158 {
 159     audiohw_postinit();
 160 }
 161
 162 /* divider is 9 bits but the highest one (for 8kHz) fit in 8 bits */
 163 static const unsigned char divider[SAMPR_NUM_FREQ] = {
 164     [HW_FREQ_96] = ((AS3525_MCLK_FREQ/128 + SAMPR_96/2) / SAMPR_96) - 1,
 165     [HW_FREQ_88] = ((AS3525_MCLK_FREQ/128 + SAMPR_88/2) / SAMPR_88) - 1,
 166     [HW_FREQ_64] = ((AS3525_MCLK_FREQ/128 + SAMPR_64/2) / SAMPR_64) - 1,
 167     [HW_FREQ_48] = ((AS3525_MCLK_FREQ/128 + SAMPR_48/2) / SAMPR_48) - 1,
 168     [HW_FREQ_44] = ((AS3525_MCLK_FREQ/128 + SAMPR_44/2) / SAMPR_44) - 1,
 169     [HW_FREQ_32] = ((AS3525_MCLK_FREQ/128 + SAMPR_32/2) / SAMPR_32) - 1,
 170     [HW_FREQ_24] = ((AS3525_MCLK_FREQ/128 + SAMPR_24/2) / SAMPR_24) - 1,
 171     [HW_FREQ_22] = ((AS3525_MCLK_FREQ/128 + SAMPR_22/2) / SAMPR_22) - 1,
 172     [HW_FREQ_16] = ((AS3525_MCLK_FREQ/128 + SAMPR_16/2) / SAMPR_16) - 1,
 173     [HW_FREQ_12] = ((AS3525_MCLK_FREQ/128 + SAMPR_12/2) / SAMPR_12) - 1,
 174     [HW_FREQ_11] = ((AS3525_MCLK_FREQ/128 + SAMPR_11/2) / SAMPR_11) - 1,
 175     [HW_FREQ_8 ] = ((AS3525_MCLK_FREQ/128 + SAMPR_8 /2) / SAMPR_8 ) - 1,
 176 };
 177
 178 static inline unsigned char mclk_divider(void)
 179 {
 180     return divider[pcm_fsel];
 181 }
 182
 183 void pcm_dma_apply_settings(void)
 184 {
 185     int cgu_audio = CGU_AUDIO;              /* read register */
 186     cgu_audio &= ~(3 << 0);                 /* clear i2sout MCLK_SEL */
 187     cgu_audio |=  (AS3525_MCLK_SEL << 0);   /* set i2sout MCLK_SEL */
 188     cgu_audio &= ~(0x1ff << 2);             /* clear i2sout divider */
 189     cgu_audio |= mclk_divider() << 2;       /* set new i2sout divider */
 190     cgu_audio &= ~(1 << 23);                /* clear I2SI_MCLK_EN */
 191     cgu_audio &= ~(1 << 24);                /* clear I2SI_MCLK2PAD_EN */
 192     CGU_AUDIO = cgu_audio;                  /* write back register */
 193 }
 194
 195 size_t pcm_get_bytes_waiting(void)
 196 {
 197     return dma_size;
 198 }
 199
 200 const void * pcm_play_dma_get_peak_buffer(int *count)
 201 {
 202     pcm_play_lock();
 203     void *addr = (void*)DMAC_CH_SRC_ADDR(1);
 204     *count = (dma_size - (addr - dma_start_addr)) >> 2;
 205     pcm_play_unlock();
 206     return AS3525_UNCACHED_ADDR(addr);
 207 }
 208
 209 #ifdef HAVE_PCM_DMA_ADDRESS
 210 void * pcm_dma_addr(void *addr)
 211 {
 212     if (addr != NULL)
 213         addr = AS3525_UNCACHED_ADDR(addr);
 214     return addr;
 215 }
 216 #endif
 217
 218
 219 /****************************************************************************
 220  ** Recording DMA transfer
 221  **/
 222 #ifdef HAVE_RECORDING
 223
 224 static int rec_locked = 0;
 225 static bool is_recording = false;
 226 static bool rec_callback_pending = false;
 227 static void *rec_dma_start_addr;
 228 static size_t rec_dma_size, rec_dma_transfer_size;
 229 static void rec_dma_callback(void);
 230 #if CONFIG_CPU == AS3525
 231 /* points to the samples which need to be duplicated into the right channel */
 232 static int16_t *mono_samples;
 233 #endif
 234
 235
 236 void pcm_rec_lock(void)
 237 {
 238     ++rec_locked;
 239 }
 240
 241
 242 void pcm_rec_unlock(void)
 243 {
 244     if(--rec_locked == 0 && is_recording)
 245     {
 246         int old = disable_irq_save();
 247         if(rec_callback_pending)
 248         {
 249             rec_callback_pending = false;
 250             rec_dma_callback();
 251         }
 252         restore_irq(old);
 253     }
 254 }
 255
 256
 257 static void rec_dma_start(void)
 258 {
 259     rec_dma_transfer_size = rec_dma_size;
 260
 261     /* We are limited to 8188 DMA transfers, and the recording core asks for
 262      * 8192 bytes. Avoid splitting 8192 bytes transfers in 8188 + 4 */
 263     if(rec_dma_transfer_size > 4096)
 264         rec_dma_transfer_size = 4096;
 265
 266     dma_enable_channel(1, (void*)I2SIN_DATA, rec_dma_start_addr, DMA_PERI_I2SIN,
 267                 DMAC_FLOWCTRL_DMAC_PERI_TO_MEM, false, true,
 268                 rec_dma_transfer_size >> 2, DMA_S4, rec_dma_callback);
 269 }
 270
 271
 272 #if CONFIG_CPU == AS3525
 273 /* if needed, duplicate samples of the working channel until the given bound */
 274 static inline void mono2stereo(int16_t *end)
 275 {
 276     if(audio_channels != 1) /* only for microphone */
 277         return;
 278 #if 0
 279     /* load pointer in a register and avoid updating it in each loop */
 280     register int16_t *samples = mono_samples;
 281
 282     do {
 283         int16_t left = *samples++;  // load 1 sample of the left-channel
 284         *samples++ = left;          // copy it in the right-channel
 285     } while(samples != end);
 286
 287     mono_samples = samples; /* update pointer */
 288 #else
 289     /* gcc doesn't use pre indexing : let's save 1 cycle */
 290     int16_t left;
 291     asm (
 292         "1: ldrh %0, [%1], #2   \n" // load 1 sample of the left-channel
 293         "   strh %0, [%1], #2   \n" // copy it in the right-channel
 294         "   cmp %1, %2          \n" // are we finished?
 295         "   bne  1b             \n"
 296         : "=&r"(left), "+r"(mono_samples)
 297         : "r"(end)
 298         : "memory"
 299     );
 300 #endif /* C / ASM */
 301 }
 302 #endif /* CONFIG_CPU == AS3525 */
 303
 304 static void rec_dma_callback(void)
 305 {
 306     if(rec_dma_transfer_size)
 307     {
 308         rec_dma_size -= rec_dma_transfer_size;
 309         rec_dma_start_addr += rec_dma_transfer_size;
 310
 311         /* don't act like we just transferred data when we are called from
 312          * pcm_rec_unlock() */
 313         rec_dma_transfer_size = 0;
 314
 315 #if CONFIG_CPU == AS3525
 316         /* the 2nd channel is silent when recording microphone on as3525v1 */
 317         mono2stereo(AS3525_UNCACHED_ADDR((int16_t*)rec_dma_start_addr));
 318 #endif
 319
 320         if(locked)
 321         {
 322             rec_callback_pending = is_recording;
 323             return;
 324         }
 325     }
 326
 327     if(!rec_dma_size)
 328     {
 329         pcm_rec_more_ready_callback(0, &rec_dma_start_addr,
 330                                     &rec_dma_size);
 331
 332         if(rec_dma_size == 0)
 333             return;
 334
 335         dump_dcache_range(rec_dma_start_addr, rec_dma_size);
 336 #if CONFIG_CPU == AS3525
 337         mono_samples = AS3525_UNCACHED_ADDR((int16_t*)rec_dma_start_addr);
 338 #endif
 339     }
 340
 341     rec_dma_start();
 342 }
 343
 344 void pcm_rec_dma_stop(void)
 345 {
 346     is_recording = false;
 347     dma_disable_channel(1);
 348     dma_release();
 349     rec_dma_size = 0;
 350
 351     I2SIN_CONTROL &= ~(1<<11); /* disable dma */
 352
 353     CGU_AUDIO &= ~(1<<11);
 354     bitclr32(&CGU_PERI, CGU_I2SIN_APB_CLOCK_ENABLE |
 355                         CGU_I2SOUT_APB_CLOCK_ENABLE);
 356
 357     rec_callback_pending = false;
 358 }
 359
 360
 361 void pcm_rec_dma_start(void *addr, size_t size)
 362 {
 363     dump_dcache_range(addr, size);
 364     rec_dma_start_addr = addr;
 365 #if CONFIG_CPU == AS3525
 366     mono_samples = AS3525_UNCACHED_ADDR(addr);
 367 #endif
 368     rec_dma_size = size;
 369
 370     dma_retain();
 371
 372     bitset32(&CGU_PERI, CGU_I2SIN_APB_CLOCK_ENABLE |
 373                         CGU_I2SOUT_APB_CLOCK_ENABLE);
 374     CGU_AUDIO |= (1<<11);
 375
 376     I2SIN_CONTROL |= (1<<11)|(1<<5); /* enable dma, 14bits samples */
 377
 378     is_recording = true;
 379
 380     rec_dma_start();
 381 }
 382
 383
 384 void pcm_rec_dma_close(void)
 385 {
 386 }
 387
 388
 389 void pcm_rec_dma_init(void)
 390 {
 391     /* i2c clk src = I2SOUTIF, sdata src = AFE,
 392      * data valid at positive edge of SCLK */
 393     I2SIN_CONTROL = (1<<2);
 394     I2SIN_MASK = 0; /* disables all interrupts */
 395 }
 396
 397
 398 const void * pcm_rec_dma_get_peak_buffer(void)
 399 {
 400 #if CONFIG_CPU == AS3525
 401     /*
 402      * We need to prevent the DMA callback from kicking in while we are
 403      * faking the right channel with data from left channel.
 404      */
 405
 406     int old = disable_irq_save();
 407     int16_t *addr = AS3525_UNCACHED_ADDR((int16_t *)DMAC_CH_DST_ADDR(1));
 408     mono2stereo(addr);
 409     restore_irq(old);
 410
 411     return addr;
 412
 413 #else
 414     /* Microphone recording is stereo on as3525v2 */
 415     return AS3525_UNCACHED_ADDR((int16_t *)DMAC_CH_DST_ADDR(1));
 416 #endif
 417 }
 418
 419 #endif /* HAVE_RECORDING */