firmware/target/arm/pcm-telechips.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2006 by Michael Sevakis
  11  * Copyright (C) 2008 by Rob Purchase
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * as published by the Free Software Foundation; either version 2
  16  * of the License, or (at your option) any later version.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ****************************************************************************/
  22 #include <stdlib.h>
  23 #include "system.h"
  24 #include "kernel.h"
  25 #include "logf.h"
  26 #include "audio.h"
  27 #include "sound.h"
  28 #include "pcm.h"
  29
  30 struct dma_data
  31 {
  32 /* NOTE: The order of size and p is important if you use assembler
  33    optimised fiq handler, so don't change it. */
  34     uint16_t *p;
  35     size_t size;
  36 #if NUM_CORES > 1
  37     unsigned core;
  38 #endif
  39     int locked;
  40     int state;
  41 };
  42
  43 /****************************************************************************
  44  ** Playback DMA transfer
  45  **/
  46 struct dma_data dma_play_data SHAREDBSS_ATTR =
  47 {
  48     /* Initialize to a locked, stopped state */
  49     .p = NULL,
  50     .size = 0,
  51 #if NUM_CORES > 1
  52     .core = 0x00,
  53 #endif
  54     .locked = 0,
  55     .state = 0
  56 };
  57
  58 void pcm_postinit(void)
  59 {
  60     audiohw_postinit();
  61 }
  62
  63 const void * pcm_play_dma_get_peak_buffer(int *count)
  64 {
  65     unsigned long addr = (unsigned long)dma_play_data.p;
  66     size_t cnt = dma_play_data.size;
  67     *count = cnt >> 2;
  68     return (void *)((addr + 2) & ~3);
  69 }
  70
  71 void pcm_play_dma_init(void)
  72 {
  73     DAVC = 0x0;         /* Digital Volume = max */
  74 #ifdef COWON_D2
  75     /* Set DAI clock divided from PLL0 (192MHz).
  76        The best approximation of 256*44.1kHz is 11.291MHz. */
  77     BCLKCTR &= ~DEV_DAI;
  78     PCLK_DAI = (1<<28) | 61682;  /* DCO mode */
  79     BCLKCTR |= DEV_DAI;
  80
  81     /* Enable DAI block in Master mode, 256fs->32fs, 16bit LSB */
  82     DAMR = 0x3c8e80;
  83 #elif defined(IAUDIO_7)
  84     BCLKCTR &= ~DEV_DAI;
  85     PCLK_DAI = (0x800a << 16) | (PCLK_DAI & 0xffff);
  86     BCLKCTR |= DEV_DAI;
  87
  88     /* Master mode, 256->64fs, 16bit LSB*/
  89     DAMR = 0x3cce20;
  90 #elif defined(LOGIK_DAX)
  91     /* TODO */
  92 #elif defined(SANSA_M200)
  93     /* TODO */
  94 #elif defined(SANSA_C100)
  95     /* TODO */
  96 #else
  97 #error "Target isn't supported"
  98 #endif
  99     /* Set DAI interrupts as FIQs */
 100     IRQSEL = ~(DAI_RX_IRQ_MASK | DAI_TX_IRQ_MASK);
 101
 102     /* Initialize default register values. */
 103     audiohw_init();
 104
 105     dma_play_data.size = 0;
 106 #if NUM_CORES > 1
 107     dma_play_data.core = 0; /* no core in control */
 108 #endif
 109 }
 110
 111 void pcm_dma_apply_settings(void)
 112 {
 113 }
 114
 115 static void play_start_pcm(void)
 116 {
 117     DAMR &= ~(1<<14);   /* disable tx */
 118     dma_play_data.state = 1;
 119
 120     if (dma_play_data.size >= 16)
 121     {
 122         DADO_L(0) = *dma_play_data.p++;
 123         DADO_R(0) = *dma_play_data.p++;
 124         DADO_L(1) = *dma_play_data.p++;
 125         DADO_R(1) = *dma_play_data.p++;
 126         DADO_L(2) = *dma_play_data.p++;
 127         DADO_R(2) = *dma_play_data.p++;
 128         DADO_L(3) = *dma_play_data.p++;
 129         DADO_R(3) = *dma_play_data.p++;
 130         dma_play_data.size -= 16;
 131     }
 132
 133     DAMR |= (1<<14);   /* enable tx */
 134 }
 135
 136 static void play_stop_pcm(void)
 137 {
 138     DAMR &= ~(1<<14);   /* disable tx */
 139     dma_play_data.state = 0;
 140 }
 141
 142 void pcm_play_dma_start(const void *addr, size_t size)
 143 {
 144     dma_play_data.p    = (uint16_t*)addr;
 145     dma_play_data.size = size;
 146
 147 #if NUM_CORES > 1
 148     /* This will become more important later - and different ! */
 149     dma_play_data.core = processor_id(); /* save initiating core */
 150 #endif
 151
 152     IEN |= DAI_TX_IRQ_MASK;
 153
 154     play_start_pcm();
 155 }
 156
 157 void pcm_play_dma_stop(void)
 158 {
 159     play_stop_pcm();
 160     dma_play_data.size = 0;
 161 #if NUM_CORES > 1
 162     dma_play_data.core = 0; /* no core in control */
 163 #endif
 164 }
 165
 166 void pcm_play_lock(void)
 167 {
 168     int status = disable_fiq_save();
 169
 170     if (++dma_play_data.locked == 1)
 171     {
 172         IEN &= ~DAI_TX_IRQ_MASK;
 173     }
 174
 175     restore_fiq(status);
 176 }
 177
 178 void pcm_play_unlock(void)
 179 {
 180    int status = disable_fiq_save();
 181
 182     if (--dma_play_data.locked == 0 && dma_play_data.state != 0)
 183     {
 184         IEN |= DAI_TX_IRQ_MASK;
 185     }
 186
 187    restore_fiq(status);
 188 }
 189
 190 void pcm_play_dma_pause(bool pause)
 191 {
 192     if (pause) {
 193         play_stop_pcm();
 194     } else {
 195         play_start_pcm();
 196     }
 197 }
 198
 199 size_t pcm_get_bytes_waiting(void)
 200 {
 201     return dma_play_data.size & ~3;
 202 }
 203
 204 #ifdef HAVE_RECORDING
 205 /* TODO: implement */
 206 void pcm_rec_dma_init(void)
 207 {
 208 }
 209
 210 void pcm_rec_dma_close(void)
 211 {
 212 }
 213
 214 void pcm_rec_dma_start(void *addr, size_t size)
 215 {
 216     (void) addr;
 217     (void) size;
 218 }
 219
 220 void pcm_rec_dma_stop(void)
 221 {
 222 }
 223
 224 void pcm_rec_lock(void)
 225 {
 226 }
 227
 228 void pcm_rec_unlock(void)
 229 {
 230 }
 231
 232 const void * pcm_rec_dma_get_peak_buffer(void)
 233 {
 234     return NULL;
 235 }
 236
 237 void pcm_record_more(void *start, size_t size)
 238 {
 239     (void) start;
 240     (void) size;
 241 }
 242 #endif
 243
 244 #if defined(CPU_TCC77X) || defined(CPU_TCC780X)
 245 void fiq_handler(void) ICODE_ATTR __attribute__((naked));
 246 void fiq_handler(void)
 247 {
 248     /* r10 contains DADO_L0 base address (set in crt0.S to minimise code in the
 249      * FIQ handler. r11 contains address of p (also set in crt0.S). Most other
 250      * addresses we need are generated by using offsets with these two.
 251      * r8 and r9 contains local copies of p and size respectively.
 252      * r0-r3 and r12 is a working register.
 253      */
 254     asm volatile (
 255 #if defined(CPU_TCC780X)
 256         "mov     r8, #0xc000         \n" /* DAI_TX_IRQ_MASK | DAI_RX_IRQ_MASK */
 257         "ldr     r9, =0xf3001004     \n" /* CREQ */
 258 #elif defined(CPU_TCC77X)
 259         "mov     r8, #0x0030         \n" /* DAI_TX_IRQ_MASK | DAI_RX_IRQ_MASK */
 260         "ldr     r9, =0x80000104     \n" /* CREQ */
 261 #endif
 262         "str     r8, [r9]            \n" /* clear DAI IRQs */
 263         "ldmia   r11, { r8-r9 }      \n" /* r8 = p, r9 = size */
 264         "cmp     r9, #0x10           \n" /* is size <16? */
 265         "blt     .more_data          \n" /* if so, ask pcmbuf for more data */
 266
 267     ".fill_fifo:                     \n"
 268         "ldr     r12, [r8], #4       \n" /* load two samples */
 269         "str     r12, [r10, #0x0]    \n" /* write top sample to DADO_L0 */
 270         "mov     r12, r12, lsr #16   \n" /* put right sample at the bottom */
 271         "str     r12, [r10, #0x4]    \n" /* write low sample to DADO_R0*/
 272         "ldr     r12, [r8], #4       \n" /* load two samples */
 273         "str     r12, [r10, #0x8]    \n" /* write top sample to DADO_L1 */
 274         "mov     r12, r12, lsr #16   \n" /* put right sample at the bottom */
 275         "str     r12, [r10, #0xc]    \n" /* write low sample to DADO_R1*/
 276         "ldr     r12, [r8], #4       \n" /* load two samples */
 277         "str     r12, [r10, #0x10]   \n" /* write top sample to DADO_L2 */
 278         "mov     r12, r12, lsr #16   \n" /* put right sample at the bottom */
 279         "str     r12, [r10, #0x14]   \n" /* write low sample to DADO_R2*/
 280         "ldr     r12, [r8], #4       \n" /* load two samples */
 281         "str     r12, [r10, #0x18]   \n" /* write top sample to DADO_L3 */
 282         "mov     r12, r12, lsr #16   \n" /* put right sample at the bottom */
 283         "str     r12, [r10, #0x1c]   \n" /* write low sample to DADO_R3*/
 284         "sub     r9, r9, #0x10       \n" /* 4 words written */
 285         "stmia   r11, { r8-r9 }      \n" /* save p and size */
 286
 287     ".exit:                          \n"
 288         "subs    pc, lr, #4          \n" /* FIQ specific return sequence */
 289
 290     ".more_data:                     \n"
 291         "stmfd   sp!, { r0-r3, lr }  \n" /* stack scratch regs and lr */
 292         "ldr     r2, =pcm_callback_for_more \n"
 293         "ldr     r2, [r2]            \n" /* get callback address */
 294         "cmp     r2, #0              \n" /* check for null pointer */
 295         "movne   r0, r11             \n" /* r0 = &p */
 296         "addne   r1, r11, #4         \n" /* r1 = &size */
 297         "blxne   r2                  \n" /* call pcm_callback_for_more */
 298         "ldmia   r11, { r8-r9 }      \n" /* reload p and size */
 299         "cmp     r9, #0x10           \n" /* did we actually get more data? */
 300         "ldmgefd sp!, { r0-r3, lr }  \n"
 301         "bge     .fill_fifo          \n" /* yes: fill the fifo */
 302         "ldr     r12, =pcm_play_dma_stop \n"
 303         "blx     r12                 \n" /* no: stop playback */
 304         "ldr     r12, =pcm_play_dma_stopped_callback \n"
 305         "blx     r12                 \n"
 306         "ldmfd   sp!, { r0-r3, lr }  \n"
 307         "b       .exit               \n"
 308         ".ltorg                      \n"
 309     );
 310 }
 311 #else /* C version for reference */
 312 void fiq_handler(void) ICODE_ATTR __attribute__((naked));
 313 void fiq_handler(void)
 314 {
 315     asm volatile(   "stmfd sp!, {r0-r7, ip, lr} \n"   /* Store context */
 316                     "sub   sp, sp, #8           \n"); /* Reserve stack */
 317
 318     register pcm_more_callback_type get_more;
 319
 320     if (dma_play_data.size < 16)
 321     {
 322         /* p is empty, get some more data */
 323         get_more = pcm_callback_for_more;
 324         if (get_more)
 325         {
 326             get_more((unsigned char**)&dma_play_data.p,
 327                      &dma_play_data.size);
 328         }
 329     }
 330
 331     if (dma_play_data.size >= 16)
 332     {
 333         DADO_L(0) = *dma_play_data.p++;
 334         DADO_R(0) = *dma_play_data.p++;
 335         DADO_L(1) = *dma_play_data.p++;
 336         DADO_R(1) = *dma_play_data.p++;
 337         DADO_L(2) = *dma_play_data.p++;
 338         DADO_R(2) = *dma_play_data.p++;
 339         DADO_L(3) = *dma_play_data.p++;
 340         DADO_R(3) = *dma_play_data.p++;
 341
 342         dma_play_data.size -= 16;
 343     }
 344     else
 345     {
 346         /* No more data, so disable the FIFO/interrupt */
 347         pcm_play_dma_stop();
 348         pcm_play_dma_stopped_callback();
 349     }
 350
 351     /* Clear FIQ status */
 352     CREQ = DAI_TX_IRQ_MASK | DAI_RX_IRQ_MASK;
 353
 354     asm volatile(   "add   sp, sp, #8           \n"   /* Cleanup stack   */
 355                     "ldmfd sp!, {r0-r7, ip, lr} \n"   /* Restore context */
 356                     "subs  pc, lr, #4           \n"); /* Return from FIQ */
 357 }
 358 #endif
 359
 360 /* TODO: required by wm8731 codec */
 361 void i2s_reset(void)
 362 {
 363     /* DAMR = 0; */
 364 }