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