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 /* Just for tests enable it to play simple tone */
  31 //#define PCM_TELECHIPS_TEST
  32
  33 struct dma_data
  34 {
  35 /* NOTE: The order of size and p is important if you use assembler
  36    optimised fiq handler, so don't change it. */
  37     uint16_t *p;
  38     size_t size;
  39 #if NUM_CORES > 1
  40     unsigned core;
  41 #endif
  42     int locked;
  43     int state;
  44 };
  45
  46 /****************************************************************************
  47  ** Playback DMA transfer
  48  **/
  49 struct dma_data dma_play_data SHAREDBSS_ATTR =
  50 {
  51     /* Initialize to a locked, stopped state */
  52     .p = NULL,
  53     .size = 0,
  54 #if NUM_CORES > 1
  55     .core = 0x00,
  56 #endif
  57     .locked = 0,
  58     .state = 0
  59 };
  60
  61 static unsigned long pcm_sampr SHAREDDATA_ATTR = HW_SAMPR_DEFAULT; /* 44.1 is default */
  62
  63 void pcm_postinit(void)
  64 {
  65     audiohw_postinit();
  66     pcm_apply_settings();
  67 }
  68
  69 const void * pcm_play_dma_get_peak_buffer(int *count)
  70 {
  71     unsigned long addr = (unsigned long)dma_play_data.p;
  72     size_t cnt = dma_play_data.size;
  73     *count = cnt >> 2;
  74     return (void *)((addr + 2) & ~3);
  75 }
  76
  77 void pcm_play_dma_init(void)
  78 {
  79     DAVC = 0x0;         /* Digital Volume = max */
  80 #ifdef COWON_D2
  81     /* Set DAI clock divided from PLL0 (192MHz).
  82        The best approximation of 256*44.1kHz is 11.291MHz. */
  83     BCLKCTR &= ~DEV_DAI;
  84     PCLK_DAI = (1<<28) | 61682;  /* DCO mode */
  85     BCLKCTR |= DEV_DAI;
  86
  87     /* Enable DAI block in Master mode, 256fs->32fs, 16bit LSB */
  88     DAMR = 0x3c8e80;
  89 #elif defined(IAUDIO_7)
  90     BCLKCTR &= ~DEV_DAI;
  91     PCLK_DAI = (0x800b << 16) | (PCLK_DAI & 0xffff);
  92     BCLKCTR |= DEV_DAI;
  93     /* Master mode, 256->64fs, 16bit LSB*/
  94     DAMR = 0x3cce20;
  95 #elif defined(LOGIK_DAX)
  96     /* TODO */
  97 #elif defined(SANSA_M200)
  98     /* TODO */
  99 #else
 100 #error "Target isn't supported"
 101 #endif
 102     /* Set DAI interrupts as FIQs */
 103     IRQSEL = ~(DAI_RX_IRQ_MASK | DAI_TX_IRQ_MASK);
 104
 105     /* Initialize default register values. */
 106     audiohw_init();
 107
 108     dma_play_data.size = 0;
 109 #if NUM_CORES > 1
 110     dma_play_data.core = 0; /* no core in control */
 111 #endif
 112 }
 113
 114 void pcm_dma_apply_settings(void)
 115 {
 116 }
 117
 118 static void play_start_pcm(void)
 119 {
 120     pcm_apply_settings();
 121
 122     DAMR &= ~(1<<14);   /* disable tx */
 123     dma_play_data.state = 1;
 124
 125     if (dma_play_data.size >= 16)
 126     {
 127         DADO_L(0) = *dma_play_data.p++;
 128         DADO_R(0) = *dma_play_data.p++;
 129         DADO_L(1) = *dma_play_data.p++;
 130         DADO_R(1) = *dma_play_data.p++;
 131         DADO_L(2) = *dma_play_data.p++;
 132         DADO_R(2) = *dma_play_data.p++;
 133         DADO_L(3) = *dma_play_data.p++;
 134         DADO_R(3) = *dma_play_data.p++;
 135         dma_play_data.size -= 16;
 136     }
 137
 138     DAMR |= (1<<14);   /* enable tx */
 139 }
 140
 141 static void play_stop_pcm(void)
 142 {
 143     DAMR &= ~(1<<14);   /* disable tx */
 144     dma_play_data.state = 0;
 145 }
 146
 147 void pcm_play_dma_start(const void *addr, size_t size)
 148 {
 149     dma_play_data.p    = (void *)(((uintptr_t)addr + 2) & ~3);
 150     dma_play_data.size = (size & ~3);
 151
 152 #if NUM_CORES > 1
 153     /* This will become more important later - and different ! */
 154     dma_play_data.core = processor_id(); /* save initiating core */
 155 #endif
 156
 157     IEN |= DAI_TX_IRQ_MASK;
 158
 159     play_start_pcm();
 160 }
 161
 162 void pcm_play_dma_stop(void)
 163 {
 164     play_stop_pcm();
 165     dma_play_data.size = 0;
 166 #if NUM_CORES > 1
 167     dma_play_data.core = 0; /* no core in control */
 168 #endif
 169 }
 170
 171 void pcm_play_lock(void)
 172 {
 173     int status = disable_fiq_save();
 174
 175     if (++dma_play_data.locked == 1)
 176     {
 177         IEN &= ~DAI_TX_IRQ_MASK;
 178     }
 179
 180     restore_fiq(status);
 181 }
 182
 183 void pcm_play_unlock(void)
 184 {
 185    int status = disable_fiq_save();
 186
 187     if (--dma_play_data.locked == 0 && dma_play_data.state != 0)
 188     {
 189         IEN |= DAI_TX_IRQ_MASK;
 190     }
 191
 192    restore_fiq(status);
 193 }
 194
 195 void pcm_play_dma_pause(bool pause)
 196 {
 197     if (pause) {
 198         play_stop_pcm();
 199     } else {
 200         play_start_pcm();
 201     }
 202 }
 203
 204 size_t pcm_get_bytes_waiting(void)
 205 {
 206     return dma_play_data.size & ~3;
 207 }
 208
 209 #ifdef HAVE_RECORDING
 210 /* TODO: implement */
 211 void pcm_rec_dma_init(void)
 212 {
 213 }
 214
 215 void pcm_rec_dma_close(void)
 216 {
 217 }
 218
 219 void pcm_rec_dma_start(void *addr, size_t size)
 220 {
 221     (void) addr;
 222     (void) size;
 223 }
 224
 225 void pcm_rec_dma_stop(void)
 226 {
 227 }
 228
 229 void pcm_rec_lock(void)
 230 {
 231 }
 232
 233 void pcm_rec_unlock(void)
 234 {
 235 }
 236
 237 const void * pcm_rec_dma_get_peak_buffer(int *count)
 238 {
 239     *count = 0;
 240     return NULL;
 241 }
 242
 243 void pcm_record_more(void *start, size_t size)
 244 {
 245     (void) start;
 246     (void) size;
 247 }
 248 #endif
 249
 250 #if defined(CPU_TCC77X) || defined(CPU_TCC780X)
 251 void fiq_handler(void) ICODE_ATTR __attribute__((naked));
 252 void fiq_handler(void)
 253 {
 254     /* r10 contains DADO_L0 base address (set in crt0.S to minimise code in the
 255      * FIQ handler. r11 contains address of p (also set in crt0.S). Most other
 256      * addresses we need are generated by using offsets with these two.
 257      * r8 and r9 contains local copies of p and size respectively.
 258      * r0-r3 and r12 is a working register.
 259      */
 260     asm volatile (
 261 #if defined(CPU_TCC780X)
 262         "mov     r8, #0xc000         \n" /* DAI_TX_IRQ_MASK | DAI_RX_IRQ_MASK */
 263         "ldr     r9, =0xf3001004     \n" /* CREQ */
 264 #elif defined(CPU_TCC77X)
 265         "mov     r8, #0x0030         \n" /* DAI_TX_IRQ_MASK | DAI_RX_IRQ_MASK */
 266         "ldr     r9, =0x80000104     \n" /* CREQ */
 267 #endif
 268         "str     r8, [r9]            \n" /* clear DAI IRQs */
 269         "ldmia   r11, { r8-r9 }      \n" /* r8 = p, r9 = size */
 270         "cmp     r9, #0x10           \n" /* is size <16? */
 271         "blt     .more_data          \n" /* if so, ask pcmbuf for more data */
 272
 273     ".fill_fifo:                     \n"
 274         "ldr     r12, [r8], #4       \n" /* load two samples */
 275         "str     r12, [r10, #0x0]    \n" /* write top sample to DADO_L0 */
 276         "mov     r12, r12, lsr #16   \n" /* put right sample at the bottom */
 277         "str     r12, [r10, #0x4]    \n" /* write low sample to DADO_R0*/
 278         "ldr     r12, [r8], #4       \n" /* load two samples */
 279         "str     r12, [r10, #0x8]    \n" /* write top sample to DADO_L1 */
 280         "mov     r12, r12, lsr #16   \n" /* put right sample at the bottom */
 281         "str     r12, [r10, #0xc]    \n" /* write low sample to DADO_R1*/
 282         "ldr     r12, [r8], #4       \n" /* load two samples */
 283         "str     r12, [r10, #0x10]   \n" /* write top sample to DADO_L2 */
 284         "mov     r12, r12, lsr #16   \n" /* put right sample at the bottom */
 285         "str     r12, [r10, #0x14]   \n" /* write low sample to DADO_R2*/
 286         "ldr     r12, [r8], #4       \n" /* load two samples */
 287         "str     r12, [r10, #0x18]   \n" /* write top sample to DADO_L3 */
 288         "mov     r12, r12, lsr #16   \n" /* put right sample at the bottom */
 289         "str     r12, [r10, #0x1c]   \n" /* write low sample to DADO_R3*/
 290         "sub     r9, r9, #0x10       \n" /* 4 words written */
 291         "stmia   r11, { r8-r9 }      \n" /* save p and size */
 292
 293     ".exit:                          \n"
 294         "subs    pc, lr, #4          \n" /* FIQ specific return sequence */
 295
 296     ".more_data:                     \n"
 297         "stmfd   sp!, { r0-r3, lr }  \n" /* stack scratch regs and lr */
 298         "ldr     r2, =pcm_callback_for_more \n"
 299         "ldr     r2, [r2]            \n" /* get callback address */
 300         "cmp     r2, #0              \n" /* check for null pointer */
 301         "movne   r0, r11             \n" /* r0 = &p */
 302         "addne   r1, r11, #4         \n" /* r1 = &size */
 303         "blxne   r2                  \n" /* call pcm_callback_for_more */
 304         "ldmia   r11, { r8-r9 }      \n" /* reload p and size */
 305         "cmp     r9, #0x10           \n" /* did we actually get more data? */
 306         "ldmgefd sp!, { r0-r3, lr }  \n"
 307         "bge     .fill_fifo          \n" /* yes: fill the fifo */
 308         "ldr     r12, =pcm_play_dma_stop \n"
 309         "blx     r12                 \n" /* no: stop playback */
 310         "ldr     r12, =pcm_play_dma_stopped_callback \n"
 311         "blx     r12                 \n"
 312         "ldmfd   sp!, { r0-r3, lr }  \n"
 313         "b       .exit               \n"
 314         ".ltorg                      \n"
 315     );
 316 }
 317 #else /* C version for reference */
 318 void fiq_handler(void) ICODE_ATTR __attribute__((naked));
 319 void fiq_handler(void)
 320 {
 321     asm volatile(   "stmfd sp!, {r0-r7, ip, lr} \n"   /* Store context */
 322                     "sub   sp, sp, #8           \n"); /* Reserve stack */
 323
 324     register pcm_more_callback_type get_more;
 325
 326     if (dma_play_data.size < 16)
 327     {
 328         /* p is empty, get some more data */
 329         get_more = pcm_callback_for_more;
 330         if (get_more)
 331         {
 332             get_more((unsigned char**)&dma_play_data.p,
 333                      &dma_play_data.size);
 334         }
 335     }
 336
 337     if (dma_play_data.size >= 16)
 338     {
 339         DADO_L(0) = *dma_play_data.p++;
 340         DADO_R(0) = *dma_play_data.p++;
 341         DADO_L(1) = *dma_play_data.p++;
 342         DADO_R(1) = *dma_play_data.p++;
 343         DADO_L(2) = *dma_play_data.p++;
 344         DADO_R(2) = *dma_play_data.p++;
 345         DADO_L(3) = *dma_play_data.p++;
 346         DADO_R(3) = *dma_play_data.p++;
 347
 348         dma_play_data.size -= 16;
 349     }
 350     else
 351     {
 352         /* No more data, so disable the FIFO/interrupt */
 353         pcm_play_dma_stop();
 354         pcm_play_dma_stopped_callback();
 355     }
 356
 357     /* Clear FIQ status */
 358     CREQ = DAI_TX_IRQ_MASK | DAI_RX_IRQ_MASK;
 359
 360     asm volatile(   "add   sp, sp, #8           \n"   /* Cleanup stack   */
 361                     "ldmfd sp!, {r0-r7, ip, lr} \n"   /* Restore context */
 362                     "subs  pc, lr, #4           \n"); /* Return from FIQ */
 363 }
 364 #endif
 365
 366 /* TODO: required by wm8531 codec, why not to implement  */
 367 void i2s_reset(void)
 368 {
 369 /* DAMR = 0; */
 370 }
 371
 372 #ifdef PCM_TELECHIPS_TEST
 373 #include "lcd.h"
 374 #include "sprintf.h"
 375 #include "backlight-target.h"
 376
 377 static int frame = 0;
 378 static void test_callback_for_more(unsigned char **start, size_t *size)
 379 {
 380     static unsigned short data[8];
 381     static int cntr = 0;
 382     int i;
 383
 384     for (i = 0; i < 8; i ++) {
 385         unsigned short val;
 386
 387         if (0x100 == (cntr & 0x100))
 388             val = 0x0fff;
 389         else
 390             val = 0x0000;
 391         data[i] = val;
 392         cntr++;
 393     }
 394
 395     *start = data;
 396     *size = sizeof(data);
 397
 398     frame++;
 399 }
 400
 401 void pcm_telechips_test(void)
 402 {
 403     static char buf[100];
 404     unsigned char *data;
 405     size_t size;
 406
 407     _backlight_on();
 408
 409     audiohw_preinit();
 410     pcm_play_dma_init();
 411     pcm_postinit();
 412
 413     audiohw_mute(false);
 414     audiohw_set_master_vol(0x7f, 0x7f);
 415
 416     pcm_callback_for_more = test_callback_for_more;
 417     test_callback_for_more(&data, &size);
 418     pcm_play_dma_start(data, size);
 419
 420     while (1) {
 421         int line = 0;
 422         lcd_clear_display();
 423         lcd_puts(0, line++, __func__);
 424         snprintf(buf, sizeof(buf), "frame: %d", frame);
 425         lcd_puts(0, line++, buf);
 426         lcd_update();
 427         sleep(1);
 428     }
 429 }
 430 #endif