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

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright © 2009 Bertrik Sikken
  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 <string.h>
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "audio.h"
  26 #include "s5l8700.h"
  27 #include "panic.h"
  28 #include "audiohw.h"
  29 #include "pcm.h"
  30 #include "pcm_sampr.h"
  31 #include "dma-target.h"
  32 #include "mmu-arm.h"
  33
  34 /*  Driver for the IIS/PCM part of the s5l8700 using DMA
  35
  36     Notes:
  37     - not all possible PCM sample rates are enabled (no support in codec driver)
  38     - pcm_play_dma_pause is untested, not sure if implemented the right way
  39     - pcm_play_dma_stop is untested, not sure if implemented the right way
  40     - recording is not implemented
  41 */
  42
  43 static volatile int locked = 0;
  44 size_t nextsize;
  45 size_t dblbufsize;
  46 int dmamode;
  47 const unsigned char* dblbuf;
  48
  49 /* table of recommended PLL/MCLK dividers for mode 256Fs from the datasheet */
  50 static const struct div_entry {
  51     int             pdiv, mdiv, sdiv, cdiv;
  52 } div_table[HW_NUM_FREQ] = {
  53 #ifdef IPOD_NANO2G
  54     [HW_FREQ_11] = {   2,   41,    5,    4},
  55     [HW_FREQ_22] = {   2,   41,    4,    4},
  56     [HW_FREQ_44] = {   2,   41,    3,    4},
  57     [HW_FREQ_88] = {   2,   41,    2,    4},
  58 #if 0   /* disabled because the codec driver does not support it (yet) */
  59     [HW_FREQ_8 ] = {   2,   12,    3,    9},
  60     [HW_FREQ_16] = {   2,   12,    2,    9},
  61     [HW_FREQ_32] = {   2,   12,    1,    9},
  62     [HW_FREQ_12] = {   2,   12,    4,    3},
  63     [HW_FREQ_24] = {   2,   12,    3,    3},
  64     [HW_FREQ_48] = {   2,   12,    2,    3},
  65     [HW_FREQ_96] = {   2,   12,    1,    3},
  66 #endif
  67 #else
  68     [HW_FREQ_11] = {  26,  189,    3,    8},
  69     [HW_FREQ_22] = {  50,   98,    2,    8},
  70     [HW_FREQ_44] = {  37,  151,    1,    9},
  71     [HW_FREQ_88] = {  50,   98,    1,    4},
  72 #if 0   /* disabled because the codec driver does not support it (yet) */
  73     [HW_FREQ_8 ] = {  28,  192,    3,   12},
  74     [HW_FREQ_16] = {  28,  192,    3,    6},
  75     [HW_FREQ_32] = {  28,  192,    2,    6},
  76     [HW_FREQ_12] = {  28,  192,    3,    8},
  77     [HW_FREQ_24] = {  28,  192,    2,    8},
  78     [HW_FREQ_48] = {  28,  192,    2,    4},
  79     [HW_FREQ_96] = {  28,  192,    1,    4},
  80 #endif
  81 #endif
  82 };
  83
  84 /* Mask the DMA interrupt */
  85 void pcm_play_lock(void)
  86 {
  87     if (locked++ == 0) {
  88         INTMSK &= ~(1 << 10);
  89     }
  90 }
  91
  92 /* Unmask the DMA interrupt if enabled */
  93 void pcm_play_unlock(void)
  94 {
  95     if (--locked == 0) {
  96         INTMSK |= (1 << 10);
  97     }
  98 }
  99
 100 static const void* dma_callback(void) ICODE_ATTR __attribute__((used));
 101 static const void* dma_callback(void)
 102 {
 103     if (dmamode)
 104     {
 105         void *dma_start_addr;
 106         pcm_play_get_more_callback(&dma_start_addr, &nextsize);
 107
 108         if (nextsize != 0)
 109         {
 110             if (nextsize >= 4096)
 111             {
 112                 dblbufsize = (nextsize >> 4) & ~3;
 113                 nextsize = nextsize - dblbufsize;
 114                 dblbuf = dma_start_addr + nextsize;
 115                 dmamode = 0;
 116             }
 117             nextsize = (nextsize >> 1) - 1;
 118             clean_dcache();
 119             return dma_start_addr;
 120         }
 121         else
 122         {
 123             nextsize = -1;
 124             return 0;
 125         }
 126     }
 127     else
 128     {
 129         dmamode = 1;
 130         nextsize = (dblbufsize >> 1) - 1;
 131         return dblbuf;
 132     }
 133 }
 134
 135 void fiq_handler(void) __attribute__((interrupt ("FIQ"), naked)) ICODE_ATTR;
 136 void fiq_handler(void)
 137 {
 138     asm volatile (
 139         "cmn    r11, #1                            \n"
 140         "strne  r10, [r8]                          \n"  /* DMABASE0 */
 141         "strne  r11, [r8,#0x08]                    \n"  /* DMATCNT0 */
 142         "strne  r9, [r8,#0x14]                     \n"  /* DMACOM0 */
 143         "moveq  r10, #5                            \n"  /* STOP DMA */
 144         "streq  r10, [r8,#0x14]                    \n"  /* DMACOM0 */
 145         "mov    r10, #7                            \n"  /* CLEAR IRQ */
 146         "str    r10, [r8,#0x14]                    \n"  /* DMACOM0 */
 147         "mov    r11, #0x39C00000                   \n"  /* SRCPND */
 148         "mov    r10, #0x00000400                   \n"  /* INT_DMA */
 149         "str    r10, [r11]                         \n"  /* ACK FIQ */
 150         "stmfd  sp!, {r0-r3,lr}                    \n"
 151         "bl     dma_callback                       \n"
 152         "mov    r10, r0                            \n"
 153         "ldmfd  sp!, {r0-r3,lr}                    \n"
 154         "ldr    r11, =nextsize                     \n"
 155         "ldr    r11, [r11]                         \n"
 156         "subs   pc, lr, #4                         \n"
 157     );
 158 }
 159
 160 void bootstrap_fiq(const void* addr, size_t tcnt) __attribute__((naked,noinline));
 161 void bootstrap_fiq(const void* addr, size_t tcnt)
 162 {
 163     (void)addr;
 164     (void)tcnt;
 165     asm volatile (
 166         "add    r2, lr, #4        \n"
 167         "mrs    r3, cpsr          \n"
 168         "msr    cpsr_c, #0xD1     \n"  /* FIQ mode, IRQ/FIQ disabled */
 169         "mov    r8, #0x38400000   \n"  /* DMA BASE */
 170         "mov    r9, #4            \n"  /* START DMA */
 171         "mov    r10, r0           \n"
 172         "mov    r11, r1           \n"
 173         "mov    r0, #0            \n"
 174         "ldr    r12, =fiq_handler \n"
 175         "ldr    sp, =_fiqstackend \n"
 176         "mov    lr, r2            \n"
 177         "msr    spsr_all, r3      \n"
 178         "bx     r12               \n"
 179     );
 180 }
 181
 182 void pcm_play_dma_start(const void *addr_in, size_t size)
 183 {
 184     unsigned char* addr = (unsigned char*)addr_in;
 185
 186     /* S1: DMA channel 0 set */
 187     DMACON0 = (0 << 30) |       /* DEVSEL */
 188               (1 << 29) |       /* DIR */
 189               (0 << 24) |       /* SCHCNT */
 190               (1 << 22) |       /* DSIZE */
 191               (0 << 19) |       /* BLEN */
 192               (0 << 18) |       /* RELOAD */
 193               (0 << 17) |       /* HCOMINT */
 194               (1 << 16) |       /* WCOMINT */
 195               (0 << 0);         /* OFFSET */
 196
 197 #ifdef IPOD_NANO2G
 198     PCON5 = (PCON5 & ~(0xFFFF0000)) | 0x77720000;
 199     PCON6 = (PCON6 & ~(0x0F000000)) | 0x02000000;
 200
 201     I2STXCON = (1 << 20) |  /* undocumented */
 202                (0 << 16) |  /* burst length */
 203                (0 << 15) |  /* 0 = falling edge */
 204                (0 << 13) |  /* 0 = basic I2S format */
 205                (0 << 12) |  /* 0 = MSB first */
 206                (0 << 11) |  /* 0 = left channel for low polarity */
 207                (5 << 8) |   /* MCLK divider */
 208                (0 << 5) |   /* 0 = 16-bit */
 209                (2 << 3) |   /* bit clock per frame */
 210                (1 << 0);    /* channel index */
 211 #else
 212     /* S2: IIS Tx mode set */
 213     I2STXCON = (DMA_IISOUT_BLEN << 16) |  /* burst length */
 214                (0 << 15) |  /* 0 = falling edge */
 215                (0 << 13) |  /* 0 = basic I2S format */
 216                (0 << 12) |  /* 0 = MSB first */
 217                (0 << 11) |  /* 0 = left channel for low polarity */
 218                (3 << 8) |   /* MCLK divider */
 219                (0 << 5) |   /* 0 = 16-bit */
 220                (0 << 3) |   /* bit clock per frame */
 221                (1 << 0);    /* channel index */
 222 #endif
 223
 224     /* S3: DMA channel 0 on */
 225     clean_dcache();
 226     if (size >= 4096)
 227     {
 228         dblbufsize = (size >> 4) & ~3;
 229         size = size - dblbufsize;
 230         dblbuf = addr + size;
 231         dmamode = 0;
 232     }
 233     else dmamode = 1;
 234     bootstrap_fiq(addr, (size >> 1) - 1);
 235
 236     /* S4: IIS Tx clock on */
 237     I2SCLKCON = (1 << 0);   /* 1 = power on */
 238
 239     /* S5: IIS Tx on */
 240     I2STXCOM = (1 << 3) |   /* 1 = transmit mode on */
 241                (1 << 2) |   /* 1 = I2S interface enable */
 242                (1 << 1) |   /* 1 = DMA request enable */
 243                (0 << 0);    /* 0 = LRCK on */
 244 }
 245
 246 void pcm_play_dma_stop(void)
 247 {
 248     /* DMA channel off */
 249     DMACOM0 = 5;
 250
 251     /* TODO Some time wait */
 252     /* LRCK half cycle wait */
 253
 254     /* IIS Tx off */
 255     I2STXCOM = (1 << 3) |   /* 1 = transmit mode on */
 256                (0 << 2) |   /* 1 = I2S interface enable */
 257                (1 << 1) |   /* 1 = DMA request enable */
 258                (0 << 0);    /* 0 = LRCK on */
 259 }
 260
 261 /* pause playback by disabling the I2S interface */
 262 void pcm_play_dma_pause(bool pause)
 263 {
 264     if (pause) {
 265         I2STXCOM |= (1 << 0);   /* LRCK off */
 266     }
 267     else {
 268         I2STXCOM &= ~(1 << 0);  /* LRCK on */
 269     }
 270 }
 271
 272 void pcm_play_dma_init(void)
 273 {
 274     /* configure IIS pins */
 275 #ifdef IPOD_NANO2G
 276     PCON5 = (PCON5 & ~(0xFFFF0000)) | 0x22220000;
 277     PCON6 = (PCON6 & ~(0x0F000000)) | 0x02000000;
 278 #else
 279     PCON7 = (PCON7 & ~(0x0FFFFF00)) | 0x02222200;
 280 #endif
 281
 282     /* enable clock to the IIS module */
 283     PWRCON &= ~(1 << 6);
 284
 285     /* Enable the DMA FIQ */
 286     INTMOD |= (1 << 10);
 287     INTMSK |= (1 << 10);
 288
 289     audiohw_preinit();
 290 }
 291
 292 void pcm_postinit(void)
 293 {
 294     audiohw_postinit();
 295 }
 296
 297 /* set the configured PCM frequency */
 298 void pcm_dma_apply_settings(void)
 299 {
 300   //    audiohw_set_frequency(pcm_sampr);
 301
 302     struct div_entry div = div_table[pcm_fsel];
 303
 304     PLLCON &= ~4;
 305     PLLCON &= ~0x10;
 306     PLLCON &= 0x3f;
 307     PLLCON |= 4;
 308
 309     /* configure PLL1 and MCLK for the desired sample rate */
 310     PLL1PMS = (div.pdiv << 16) |
 311               (div.mdiv << 8) |
 312               (div.sdiv << 0);
 313     PLL1LCNT = 7500;    /* no idea what to put here */
 314
 315     /* enable PLL1 and wait for lock */
 316     PLLCON |= (1 << 1);
 317     while ((PLLLOCK & (1 << 1)) == 0);
 318
 319     /* configure MCLK */
 320     CLKCON = (CLKCON & ~(0xFF)) |
 321              (0 << 7) |         /* MCLK_MASK */
 322              (2 << 5) |         /* MCLK_SEL = PLL1 */
 323              (1 << 4) |         /* MCLK_DIV_ON */
 324              (div.cdiv - 1);    /* MCLK_DIV_VAL */
 325 }
 326
 327 size_t pcm_get_bytes_waiting(void)
 328 {
 329     return (nextsize + DMACTCNT0 + 2) << 1;
 330 }
 331
 332 const void * pcm_play_dma_get_peak_buffer(int *count)
 333 {
 334     *count = DMACTCNT0 >> 1;
 335     return (void *)(((DMACADDR0 + 2) & ~3) | 0x40000000);
 336 }
 337
 338 #ifdef HAVE_PCM_DMA_ADDRESS
 339 void * pcm_dma_addr(void *addr)
 340 {
 341     if (addr != NULL)
 342         addr = (void*)((uintptr_t)addr | 0x40000000);
 343     return addr;
 344 }
 345 #endif
 346
 347
 348 /****************************************************************************
 349  ** Recording DMA transfer
 350  **/
 351 #ifdef HAVE_RECORDING
 352 void pcm_rec_lock(void)
 353 {
 354 }
 355
 356 void pcm_rec_unlock(void)
 357 {
 358 }
 359
 360 void pcm_rec_dma_stop(void)
 361 {
 362 }
 363
 364 void pcm_rec_dma_start(void *addr, size_t size)
 365 {
 366     (void)addr;
 367     (void)size;
 368 }
 369
 370 void pcm_rec_dma_close(void)
 371 {
 372 }
 373
 374
 375 void pcm_rec_dma_init(void)
 376 {
 377 }
 378
 379
 380 const void * pcm_rec_dma_get_peak_buffer(void)
 381 {
 382     return NULL;
 383 }
 384
 385 #endif /* HAVE_RECORDING */