firmware/target/arm/pcm-pp.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2006 by Michael Sevakis
  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 <stdlib.h>
  22 #include "system.h"
  23 #include "kernel.h"
  24 #include "logf.h"
  25 #include "audio.h"
  26 #include "sound.h"
  27 #include "pcm.h"
  28 #include "pcm_sampr.h"
  29
  30 /** DMA **/
  31
  32 #ifdef CPU_PP502x
  33 /* 16-bit, L-R packed into 32 bits with left in the least significant halfword */
  34 #define SAMPLE_SIZE   16
  35 /* DMA Requests from IIS, Memory to peripheral, single transfer,
  36    wait for DMA request, interrupt on complete */
  37 #define DMA_PLAY_CONFIG ((DMA_REQ_IIS << DMA_CMD_REQ_ID_POS) | \
  38                           DMA_CMD_RAM_TO_PER | DMA_CMD_SINGLE | \
  39                           DMA_CMD_WAIT_REQ | DMA_CMD_INTR)
  40 /* DMA status cannot be viewed from outside code in control because that can
  41  * clear the interrupt from outside the handler and prevent the handler from
  42  * from being called. Split up transfers to a reasonable size that is good as
  43  * a timer, obtaining a keyclick position and peaking yet still keeps the
  44  * FIQ count low.
  45  */
  46 #define MAX_DMA_CHUNK_SIZE (pcm_curr_sampr >> 6) /* ~1/256 seconds */
  47 #else
  48 /* 32-bit, one left 32-bit sample followed by one right 32-bit sample */
  49 #define SAMPLE_SIZE   32
  50 #endif
  51
  52 struct dma_data
  53 {
  54 /* NOTE: The order of size and p is important if you use assembler
  55    optimised fiq handler, so don't change it. */
  56     union
  57     {
  58         unsigned long addr;
  59         uint32_t *p16;  /* For packed 16-16 stereo pairs */
  60         uint16_t *p32;  /* For individual samples converted to 32-bit */
  61     };
  62     size_t size;
  63 #if NUM_CORES > 1
  64     unsigned core;
  65 #endif
  66     int locked;
  67     int state;
  68 };
  69
  70 extern void *fiq_function;
  71
  72 /* Dispatch to the proper handler and leave the main vector table alone */
  73 void fiq_handler(void) ICODE_ATTR __attribute__((naked));
  74 void fiq_handler(void)
  75 {
  76     asm volatile (
  77         "ldr pc, [pc, #-4] \n"
  78     "fiq_function:         \n"
  79         ".word 0           \n"
  80     );
  81 }
  82
  83 #ifdef HAVE_PCM_DMA_ADDRESS
  84 void * pcm_dma_addr(void *addr)
  85 {
  86     if (addr != NULL && (unsigned long)addr < UNCACHED_BASE_ADDR)
  87         addr = UNCACHED_ADDR(addr);
  88     return addr;
  89 }
  90 #endif
  91
  92 /* TODO: Get simultaneous recording and playback to work. Just needs some tweaking */
  93
  94 /****************************************************************************
  95  ** Playback DMA transfer
  96  **/
  97 static struct dma_data dma_play_data IBSS_ATTR =
  98 {
  99     /* Initialize to a locked, stopped state */
 100     { .addr = 0 },
 101     .size = 0,
 102 #if NUM_CORES > 1
 103     .core = 0x00,
 104 #endif
 105     .locked = 0,
 106     .state = 0
 107 };
 108
 109 void pcm_dma_apply_settings(void)
 110 {
 111     audiohw_set_frequency(pcm_fsel);
 112 }
 113
 114 #if defined(CPU_PP502x)
 115 /* NOTE: direct stack use forbidden by GCC stack handling bug for FIQ */
 116 void ICODE_ATTR __attribute__((interrupt("FIQ"))) fiq_playback(void)
 117 {
 118     register pcm_more_callback_type get_more;
 119     register size_t size;
 120
 121     DMA0_STATUS; /* Clear any pending interrupt */
 122
 123     size = (DMA0_CMD & 0xffff) + 4; /* Get size of trasfer that caused this
 124                                        interrupt */
 125     dma_play_data.addr += size;
 126     dma_play_data.size -= size;
 127
 128     while (1)
 129     {
 130         if (dma_play_data.size > 0) {
 131             size = MAX_DMA_CHUNK_SIZE;
 132             /* Not at least MAX_DMA_CHUNK_SIZE left or there would be less
 133              * than a FIFO's worth of data after this transfer? */
 134             if (size + 16*4 > dma_play_data.size)
 135                 size = dma_play_data.size;
 136
 137             /* Set the new DMA values and activate channel */
 138             DMA0_RAM_ADDR = dma_play_data.addr;
 139             DMA0_CMD = DMA_PLAY_CONFIG | (size - 4) | DMA_CMD_START;
 140             return;
 141         }
 142
 143         /* Buffer empty.  Try to get more. */
 144         get_more = pcm_callback_for_more;
 145         if (get_more) {
 146             get_more((unsigned char **)&dma_play_data.addr, &dma_play_data.size);
 147             dma_play_data.addr = (dma_play_data.addr + 2) & ~3;
 148             dma_play_data.size &= ~3;
 149         }
 150
 151         if (dma_play_data.size == 0) {
 152             break;
 153         }
 154
 155         if (dma_play_data.addr < UNCACHED_BASE_ADDR) {
 156             /* Flush any pending cache writes */
 157             dma_play_data.addr = UNCACHED_ADDR(dma_play_data.addr);
 158             cpucache_flush();
 159         }
 160     }
 161
 162     /* Callback missing or no more DMA to do */
 163     pcm_play_dma_stop();
 164     pcm_play_dma_stopped_callback();
 165 }
 166 #else
 167 /* ASM optimised FIQ handler. Checks for the minimum allowed loop cycles by
 168  * evalutation of free IISFIFO-slots against available source buffer words.
 169  * Through this it is possible to move the check for IIS_TX_FREE_COUNT outside
 170  * the loop and do some further optimization. Right after the loops (source
 171  * buffer -> IISFIFO) are done we need to check whether we have to exit FIQ
 172  * handler (this must be done, if all free FIFO slots were filled) or we will
 173  * have to get some new source data. Important information kept from former
 174  * ASM implementation (not used anymore): GCC fails to make use of the fact
 175  * that FIQ mode has registers r8-r14 banked, and so does not need to be saved.
 176  * This routine uses only these registers, and so will never touch the stack
 177  * unless it actually needs to do so when calling pcm_callback_for_more.
 178  * C version is still included below for reference and testing.
 179  */
 180 #if 1
 181 void fiq_playback(void) ICODE_ATTR __attribute__((naked));
 182 void fiq_playback(void)
 183 {
 184     /* r10 contains IISCONFIG address (set in crt0.S to minimise code in actual
 185      * FIQ handler. r11 contains address of p (also set in crt0.S). Most other
 186      * addresses we need are generated by using offsets with these two.
 187      * r10 + 0x40 is IISFIFO_WR, and r10 + 0x0c is IISFIFO_CFG.
 188      * r8 and r9 contains local copies of p and size respectively.
 189      * r0-r3 and r12 is a working register.
 190      */
 191     asm volatile (
 192         "stmfd   sp!, { r0-r3, lr }  \n" /* stack scratch regs and lr */
 193
 194 #if CONFIG_CPU == PP5002
 195         "ldr     r12, =0xcf001040    \n" /* Some magic from iPodLinux */
 196         "ldr     r12, [r12]          \n"
 197 #endif
 198         "ldmia   r11, { r8-r9 }      \n" /* r8 = p, r9 = size */
 199         "cmp     r9, #0              \n" /* is size 0? */
 200         "beq     .more_data          \n" /* if so, ask pcmbuf for more data */
 201
 202 #if SAMPLE_SIZE == 16
 203     ".check_fifo:                    \n"
 204         "ldr     r0, [r10, %[cfg]]   \n" /* read IISFIFO_CFG to check FIFO status */
 205         "and     r0, r0, %[mask]     \n" /* r0 = IIS_TX_FREE_COUNT << 16 (PP502x) */
 206
 207         "mov     r1, r0, lsr #16     \n" /* number of free FIFO slots */
 208         "cmp     r1, r9, lsr #2      \n" /* number of words from source */
 209         "movgt   r1, r9, lsr #2      \n" /* r1 = amount of allowed loops */
 210         "sub     r9, r9, r1, lsl #2  \n" /* r1 words will be written in following loop */
 211
 212         "subs    r1, r1, #2          \n"
 213     ".fifo_loop_2:                   \n"
 214         "ldmgeia r8!, {r2, r12}      \n" /* load four samples */
 215         "strge   r2 , [r10, %[wr]]   \n" /* write sample 0-1 to IISFIFO_WR */
 216         "strge   r12, [r10, %[wr]]   \n" /* write sample 2-3 to IISFIFO_WR */
 217         "subges  r1, r1, #2          \n" /* one more loop? */
 218         "bge     .fifo_loop_2        \n" /* yes, continue */
 219
 220         "tst     r1, #1              \n" /* two samples (one word) left? */
 221         "ldrne   r12, [r8], #4       \n" /* load two samples */
 222         "strne   r12, [r10, %[wr]]   \n" /* write sample 0-1 to IISFIFO_WR */
 223
 224         "cmp     r9, #0              \n" /* either FIFO is full or source buffer is empty */
 225         "bgt     .exit               \n" /* if source buffer is not empty, FIFO must be full */
 226 #elif SAMPLE_SIZE == 32
 227     ".check_fifo:                    \n"
 228         "ldr     r0, [r10, %[cfg]]   \n" /* read IISFIFO_CFG to check FIFO status */
 229         "and     r0, r0, %[mask]     \n" /* r0 = IIS_TX_FREE_COUNT << 23 (PP5002) */
 230
 231         "movs    r1, r0, lsr #24     \n" /* number of free pairs of FIFO slots */
 232         "beq     .exit               \n" /* no complete pair? -> exit */
 233         "cmp     r1, r9, lsr #2      \n" /* number of words from source */
 234         "movgt   r1, r9, lsr #2      \n" /* r1 = amount of allowed loops */
 235         "sub     r9, r9, r1, lsl #2  \n" /* r1 words will be written in following loop */
 236
 237     ".fifo_loop:                     \n"
 238         "ldr     r12, [r8], #4       \n" /* load two samples */
 239         "mov     r2 , r12, lsl #16   \n" /* put left sample at the top bits */
 240         "str     r2 , [r10, %[wr]]   \n" /* write top sample to IISFIFO_WR */
 241         "str     r12, [r10, %[wr]]   \n" /* write low sample to IISFIFO_WR*/
 242         "subs    r1, r1, #1          \n" /* one more loop? */
 243         "bgt     .fifo_loop          \n" /* yes, continue */
 244
 245         "cmp     r9, #0              \n" /* either FIFO is full or source buffer is empty */
 246         "bgt     .exit               \n" /* if source buffer is not empty, FIFO must be full */
 247 #endif
 248
 249     ".more_data:                     \n"
 250         "ldr     r2, =pcm_callback_for_more \n"
 251         "ldr     r2, [r2]            \n" /* get callback address */
 252         "cmp     r2, #0              \n" /* check for null pointer */
 253         "beq     .stop               \n" /* callback removed, stop */
 254         "stmia   r11, { r8-r9 }      \n" /* save internal copies of variables back */
 255         "mov     r0, r11             \n" /* r0 = &p */
 256         "add     r1, r11, #4         \n" /* r1 = &size */
 257         "mov     lr, pc              \n" /* call pcm_callback_for_more */
 258         "bx      r2                  \n"
 259         "ldmia   r11, { r8-r9 }      \n" /* reload p and size */
 260         "cmp     r9, #0              \n" /* did we actually get more data? */
 261         "bne     .check_fifo         \n"
 262
 263     ".stop:                          \n" /* call termination routines */
 264         "ldr     r12, =pcm_play_dma_stop \n"
 265         "mov     lr, pc              \n"
 266         "bx      r12                 \n"
 267         "ldr     r12, =pcm_play_dma_stopped_callback \n"
 268         "mov     lr, pc              \n"
 269         "bx      r12                 \n"
 270
 271     ".exit:                          \n" /* (r8=0 if stopping, look above) */
 272         "stmia   r11, { r8-r9 }      \n" /* save p and size */
 273         "ldmfd   sp!, { r0-r3, lr }  \n"
 274         "subs    pc, lr, #4          \n" /* FIQ specific return sequence */
 275         ".ltorg                      \n"
 276         : /* These must only be integers! No regs */
 277         : [mask]"i"(IIS_TX_FREE_MASK),
 278           [cfg]"i"((int)&IISFIFO_CFG - (int)&IISCONFIG),
 279           [wr]"i"((int)&IISFIFO_WR - (int)&IISCONFIG)
 280     );
 281 }
 282 #else /* C version for reference */
 283 void fiq_playback(void) __attribute__((interrupt ("FIQ"))) ICODE_ATTR;
 284 /* NOTE: direct stack use forbidden by GCC stack handling bug for FIQ */
 285 void fiq_playback(void)
 286 {
 287     register pcm_more_callback_type get_more;
 288
 289 #if CONFIG_CPU == PP5002
 290     inl(0xcf001040);
 291 #endif
 292
 293     do {
 294         while (dma_play_data.size > 0) {
 295             if (IIS_TX_FREE_COUNT < 2) {
 296                 return;
 297             }
 298 #if SAMPLE_SIZE == 16
 299             IISFIFO_WR = *dma_play_data.p16++;
 300 #elif SAMPLE_SIZE == 32
 301             IISFIFO_WR = *dma_play_data.p32++ << 16;
 302             IISFIFO_WR = *dma_play_data.p32++ << 16;
 303 #endif
 304             dma_play_data.size -= 4;
 305         }
 306
 307         /* p is empty, get some more data */
 308         get_more = pcm_callback_for_more;
 309         if (get_more) {
 310             get_more((unsigned char**)&dma_play_data.addr,
 311                      &dma_play_data.size);
 312         }
 313     } while (dma_play_data.size);
 314
 315     /* No more data, so disable the FIFO/interrupt */
 316     pcm_play_dma_stop();
 317     pcm_play_dma_stopped_callback();
 318 }
 319 #endif /* ASM / C selection */
 320 #endif /* CPU_PP502x */
 321
 322 /* For the locks, FIQ must be disabled because the handler manipulates
 323    IISCONFIG and the operation is not atomic - dual core support
 324    will require other measures */
 325 void pcm_play_lock(void)
 326 {
 327     int status = disable_fiq_save();
 328
 329     if (++dma_play_data.locked == 1) {
 330 #ifdef CPU_PP502x
 331         CPU_INT_DIS = DMA_MASK;
 332 #else
 333         IIS_IRQTX_REG &= ~IIS_IRQTX;
 334 #endif
 335     }
 336
 337     restore_fiq(status);
 338 }
 339
 340 void pcm_play_unlock(void)
 341 {
 342    int status = disable_fiq_save();
 343
 344     if (--dma_play_data.locked == 0 && dma_play_data.state != 0) {
 345 #ifdef CPU_PP502x
 346         CPU_INT_EN = DMA_MASK;
 347 #else
 348         IIS_IRQTX_REG |= IIS_IRQTX;
 349 #endif
 350     }
 351
 352    restore_fiq(status);
 353 }
 354
 355 static void play_start_pcm(void)
 356 {
 357     fiq_function = fiq_playback;
 358
 359 #ifdef CPU_PP502x
 360     /* Not at least MAX_DMA_CHUNK_SIZE left or there would be less than a
 361      * FIFO's worth of data after this transfer? */
 362     size_t size = MAX_DMA_CHUNK_SIZE;
 363     if (size + 16*4 > dma_play_data.size)
 364         size = dma_play_data.size;
 365
 366     DMA0_RAM_ADDR = dma_play_data.addr;
 367     DMA0_CMD = DMA_PLAY_CONFIG | (size - 4) | DMA_CMD_START;
 368     dma_play_data.state = 1;
 369 #else
 370     IISCONFIG &= ~IIS_TXFIFOEN;  /* Stop transmitting */
 371
 372     /* Fill the FIFO or start when data is used up */
 373     while (1) {
 374         if (IIS_TX_FREE_COUNT < 2 || dma_play_data.size == 0) {
 375             IISCONFIG |= IIS_TXFIFOEN; /* Start transmitting */
 376             dma_play_data.state = 1;
 377             return;
 378         }
 379
 380 #if SAMPLE_SIZE == 16
 381         IISFIFO_WR = *dma_play_data.p16++;
 382 #elif SAMPLE_SIZE == 32
 383         IISFIFO_WR = *dma_play_data.p32++ << 16;
 384         IISFIFO_WR = *dma_play_data.p32++ << 16;
 385 #endif
 386         dma_play_data.size -= 4;
 387     }
 388 #endif
 389 }
 390
 391 static void play_stop_pcm(void)
 392 {
 393 #ifdef CPU_PP502x
 394     unsigned long status = DMA0_STATUS; /* Snapshot- resume from this point */
 395     unsigned long cmd = DMA0_CMD;
 396     size_t size = 0;
 397
 398     /* Stop transfer */
 399     DMA0_CMD = cmd & ~(DMA_CMD_START | DMA_CMD_INTR);
 400
 401     /* Wait for not busy + clear int */
 402     while (DMA0_STATUS & (DMA_STATUS_BUSY | DMA_STATUS_INTR));
 403
 404     if (status & DMA_STATUS_BUSY) {
 405         /* Transfer was interrupted - leave what's left */
 406         size = (cmd & 0xfffc) - (status & 0xfffc);
 407     }
 408     else if (status & DMA_STATUS_INTR) {
 409         /* Transfer was finished - DMA0_STATUS will have been reloaded
 410          * automatically with size in DMA0_CMD. Setup to restart on next
 411          * segment. */
 412         size = (cmd & 0xfffc) + 4;
 413     }
 414     /* else not an active state - size = 0 */
 415
 416     dma_play_data.addr += size;
 417     dma_play_data.size -= size;
 418
 419     if (dma_play_data.size == 0)
 420         dma_play_data.addr = 0; /* Entire buffer has completed. */
 421 #else
 422     /* Disable TX interrupt */
 423     IIS_IRQTX_REG &= ~IIS_IRQTX;
 424 #endif
 425
 426     /* Wait for FIFO to empty */
 427     while (!IIS_TX_IS_EMPTY);
 428
 429     dma_play_data.state = 0;
 430 }
 431
 432 void pcm_play_dma_start(const void *addr, size_t size)
 433 {
 434 #if NUM_CORES > 1
 435     /* This will become more important later - and different ! */
 436     dma_play_data.core = processor_id(); /* save initiating core */
 437 #endif
 438
 439     pcm_play_dma_stop();
 440
 441 #ifdef CPU_PP502x
 442     if ((unsigned long)addr < UNCACHED_BASE_ADDR) {
 443         /* Flush any pending cache writes */
 444         addr = UNCACHED_ADDR(addr);
 445         cpucache_flush();
 446     }
 447
 448     dma_play_data.addr = (unsigned long)addr;
 449     dma_play_data.size = size;
 450     DMA0_PER_ADDR = (unsigned long)&IISFIFO_WR;
 451     DMA0_FLAGS = DMA_FLAGS_UNK26;
 452     DMA0_INCR = DMA_INCR_RANGE_FIXED | DMA_INCR_WIDTH_32BIT;
 453 #else
 454     dma_play_data.addr = (unsigned long)addr;
 455     dma_play_data.size = size;
 456 #endif
 457
 458     play_start_pcm();
 459 }
 460
 461 /* Stops the DMA transfer and interrupt */
 462 void pcm_play_dma_stop(void)
 463 {
 464     play_stop_pcm();
 465     dma_play_data.addr = 0;
 466     dma_play_data.size = 0;
 467 #if NUM_CORES > 1
 468     dma_play_data.core = 0; /* no core in control */
 469 #endif
 470 }
 471
 472 void pcm_play_dma_pause(bool pause)
 473 {
 474     if (pause) {
 475         play_stop_pcm();
 476     } else {
 477         play_start_pcm();
 478     }
 479 }
 480
 481 size_t pcm_get_bytes_waiting(void)
 482 {
 483     return dma_play_data.size & ~3;
 484 }
 485
 486 void pcm_play_dma_init(void)
 487 {
 488     /* Initialize default register values. */
 489     audiohw_init();
 490
 491 #ifdef CPU_PP502x
 492     /* Enable DMA controller */
 493     DMA_MASTER_CONTROL |= DMA_MASTER_CONTROL_EN;
 494     /* FIQ priority for DMA */
 495     CPU_INT_PRIORITY |= DMA_MASK;
 496     /* Enable request?? Not setting or clearing everything doesn't seem to
 497      * prevent it operating. Perhaps important for reliability (how requests
 498      * are handled). */
 499     DMA_REQ_STATUS |= 1ul << DMA_REQ_IIS;
 500     DMA0_STATUS;
 501 #else
 502     /* Set up banked registers for FIQ mode */
 503
 504     /* Use non-banked registers for scratch. */
 505     register volatile void *iiscfg asm("r0") = &IISCONFIG;
 506     register volatile void *dmapd asm("r1") = &dma_play_data;
 507
 508     asm volatile (
 509         "mrs    r2, cpsr            \n" /* Save mode and interrupt status */
 510         "msr    cpsr_c, #0xd1       \n" /* Switch to FIQ mode */
 511         "mov    r8, #0              \n"
 512         "mov    r9, #0              \n"
 513         "mov    r10, %[iiscfg]      \n"
 514         "mov    r11, %[dmapd]       \n"
 515         "msr    cpsr_c, r2          \n"
 516         :
 517         : [iiscfg]"r"(iiscfg), [dmapd]"r"(dmapd)
 518         : "r2");
 519
 520     /* FIQ priority for I2S */
 521     CPU_INT_PRIORITY |= IIS_MASK;
 522     CPU_INT_EN = IIS_MASK;
 523 #endif
 524
 525     IISCONFIG |= IIS_TXFIFOEN;
 526 }
 527
 528 void pcm_postinit(void)
 529 {
 530     audiohw_postinit();
 531 }
 532
 533 const void * pcm_play_dma_get_peak_buffer(int *count)
 534 {
 535     unsigned long addr, size;
 536
 537     int status = disable_fiq_save();
 538     addr = dma_play_data.addr;
 539     size = dma_play_data.size;
 540     restore_fiq(status);
 541
 542     *count = size >> 2;
 543     return (void *)((addr + 2) & ~3);
 544 }
 545
 546 /****************************************************************************
 547  ** Recording DMA transfer
 548  **/
 549 #ifdef HAVE_RECORDING
 550 /* PCM recording interrupt routine lockout */
 551 static struct dma_data dma_rec_data IBSS_ATTR =
 552 {
 553     /* Initialize to a locked, stopped state */
 554     { .addr = 0 },
 555     .size = 0,
 556 #if NUM_CORES > 1
 557     .core = 0x00,
 558 #endif
 559     .locked = 0,
 560     .state  = 0
 561 };
 562
 563 /* For the locks, FIQ must be disabled because the handler manipulates
 564    IISCONFIG and the operation is not atomic - dual core support
 565    will require other measures */
 566 void pcm_rec_lock(void)
 567 {
 568     int status = disable_fiq_save();
 569
 570     if (++dma_rec_data.locked == 1)
 571         IIS_IRQRX_REG &= ~IIS_IRQRX;
 572
 573     restore_fiq(status);
 574 }
 575
 576 void pcm_rec_unlock(void)
 577 {
 578     int status = disable_fiq_save();
 579
 580     if (--dma_rec_data.locked == 0 && dma_rec_data.state != 0)
 581         IIS_IRQRX_REG |= IIS_IRQRX;
 582
 583     restore_fiq(status);
 584 }
 585
 586 /* NOTE: direct stack use forbidden by GCC stack handling bug for FIQ */
 587 void fiq_record(void) ICODE_ATTR __attribute__((interrupt ("FIQ")));
 588
 589 #if defined(SANSA_C200) || defined(SANSA_E200)
 590 void fiq_record(void)
 591 {
 592     register pcm_more_callback_type2 more_ready;
 593     register int32_t value;
 594
 595     if (audio_channels == 2) {
 596         /* RX is stereo */
 597         while (dma_rec_data.size > 0) {
 598             if (IIS_RX_FULL_COUNT < 2) {
 599                 return;
 600             }
 601
 602             /* Discard every other sample since ADC clock is 1/2 LRCK */
 603             value = IISFIFO_RD;
 604             IISFIFO_RD;
 605
 606             *dma_rec_data.p16++ = value;
 607             dma_rec_data.size -= 4;
 608
 609             /* TODO: Figure out how to do IIS loopback */
 610             if (audio_output_source != AUDIO_SRC_PLAYBACK) {
 611                 if (IIS_TX_FREE_COUNT >= 16) {
 612                     /* Resync the output FIFO - it ran dry */
 613                     IISFIFO_WR = 0;
 614                     IISFIFO_WR = 0;
 615                 }
 616                 IISFIFO_WR = value;
 617                 IISFIFO_WR = value;
 618             }
 619         }
 620     }
 621     else {
 622         /* RX is left channel mono */
 623         while (dma_rec_data.size > 0) {
 624             if (IIS_RX_FULL_COUNT < 2) {
 625                 return;
 626             }
 627
 628             /* Discard every other sample since ADC clock is 1/2 LRCK */
 629             value = IISFIFO_RD;
 630             IISFIFO_RD;
 631
 632             value = (uint16_t)value | (value << 16);
 633
 634             *dma_rec_data.p16++ = value;
 635             dma_rec_data.size -= 4;
 636
 637             if (audio_output_source != AUDIO_SRC_PLAYBACK) {
 638                 if (IIS_TX_FREE_COUNT >= 16) {
 639                     /* Resync the output FIFO - it ran dry */
 640                     IISFIFO_WR = 0;
 641                     IISFIFO_WR = 0;
 642                 }
 643
 644                 value = *((int32_t *)dma_rec_data.p16 - 1);
 645                 IISFIFO_WR = value;
 646                 IISFIFO_WR = value;
 647             }
 648         }
 649     }
 650
 651     more_ready = pcm_callback_more_ready;
 652
 653     if (more_ready == NULL || more_ready(0) < 0) {
 654         /* Finished recording */
 655         pcm_rec_dma_stop();
 656         pcm_rec_dma_stopped_callback();
 657     }
 658 }
 659
 660 #else
 661 void fiq_record(void)
 662 {
 663     register pcm_more_callback_type2 more_ready;
 664
 665     while (dma_rec_data.size > 0) {
 666         if (IIS_RX_FULL_COUNT < 2) {
 667             return;
 668         }
 669
 670 #if SAMPLE_SIZE == 16
 671         *dma_rec_data.p16++ = IISFIFO_RD;
 672 #elif SAMPLE_SIZE == 32
 673         *dma_rec_data.p32++ = IISFIFO_RD >> 16;
 674         *dma_rec_data.p32++ = IISFIFO_RD >> 16;
 675 #endif
 676         dma_rec_data.size -= 4;
 677     }
 678
 679     more_ready = pcm_callback_more_ready;
 680
 681     if (more_ready == NULL || more_ready(0) < 0) {
 682         /* Finished recording */
 683         pcm_rec_dma_stop();
 684         pcm_rec_dma_stopped_callback();
 685     }
 686 }
 687
 688 #endif /* SANSA_E200 */
 689
 690 /* Continue transferring data in */
 691 void pcm_rec_dma_record_more(void *start, size_t size)
 692 {
 693     dma_rec_data.addr = (unsigned long)start; /* Start of RX buffer */
 694     dma_rec_data.size = size; /* Bytes to transfer */
 695 }
 696
 697 void pcm_rec_dma_stop(void)
 698 {
 699     /* disable interrupt */
 700     IIS_IRQRX_REG &= ~IIS_IRQRX;
 701
 702     dma_rec_data.state = 0;
 703     dma_rec_data.size = 0;
 704 #if NUM_CORES > 1
 705     dma_rec_data.core = 0x00;
 706 #endif
 707
 708     /* disable fifo */
 709     IISCONFIG &= ~IIS_RXFIFOEN;
 710     IISFIFO_CFG |= IIS_RXCLR;
 711 }
 712
 713 void pcm_rec_dma_start(void *addr, size_t size)
 714 {
 715     pcm_rec_dma_stop();
 716
 717     dma_rec_data.addr = (unsigned long)addr;
 718     dma_rec_data.size = size;
 719 #if NUM_CORES > 1
 720     /* This will become more important later - and different ! */
 721     dma_rec_data.core = processor_id(); /* save initiating core */
 722 #endif
 723     /* setup FIQ handler */
 724     fiq_function = fiq_record;
 725
 726     /* interrupt on full fifo, enable record fifo interrupt */
 727     dma_rec_data.state = 1;
 728
 729     /* enable RX FIFO */
 730     IISCONFIG |= IIS_RXFIFOEN;
 731
 732     /* enable IIS interrupt as FIQ */
 733     CPU_INT_PRIORITY |= IIS_MASK;
 734     CPU_INT_EN = IIS_MASK;
 735 }
 736
 737 void pcm_rec_dma_close(void)
 738 {
 739     pcm_rec_dma_stop();
 740 } /* pcm_close_recording */
 741
 742 void pcm_rec_dma_init(void)
 743 {
 744     pcm_rec_dma_stop();
 745 } /* pcm_init */
 746
 747 const void * pcm_rec_dma_get_peak_buffer(void)
 748 {
 749     return (void *)((unsigned long)dma_rec_data.addr & ~3);
 750 } /* pcm_rec_dma_get_peak_buffer */
 751
 752 #endif /* HAVE_RECORDING */