firmware/drivers/audio/wm8975.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Driver for WM8975 audio codec
  11  *
  12  * Based on code from the ipodlinux project - http://ipodlinux.org/
  13  * Adapted for Rockbox in December 2005
  14  *
  15  * Original file: linux/arch/armnommu/mach-ipod/audio.c
  16  *
  17  * Copyright (c) 2003-2005 Bernard Leach (leachbj@bouncycastle.org)
  18  *
  19  * This program is free software; you can redistribute it and/or
  20  * modify it under the terms of the GNU General Public License
  21  * as published by the Free Software Foundation; either version 2
  22  * of the License, or (at your option) any later version.
  23  *
  24  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  25  * KIND, either express or implied.
  26  *
  27  ****************************************************************************/
  28 #include "logf.h"
  29 #include "system.h"
  30 #include "string.h"
  31 #include "audio.h"
  32 #include "sound.h"
  33
  34 #include "wmcodec.h"
  35 #include "audiohw.h"
  36
  37 const struct sound_settings_info audiohw_settings[] = {
  38     [SOUND_VOLUME]        = {"dB", 0,  1, -74,   6, -25},
  39     [SOUND_BASS]          = {"dB", 0,  1,  -6,   9,   0},
  40     [SOUND_TREBLE]        = {"dB", 0,  1,  -6,   9,   0},
  41     [SOUND_BALANCE]       = {"%",  0,  1,-100, 100,   0},
  42     [SOUND_CHANNELS]      = {"",   0,  1,   0,   5,   0},
  43     [SOUND_STEREO_WIDTH]  = {"%",  0,  5,   0, 250, 100},
  44 #ifdef HAVE_RECORDING
  45     [SOUND_LEFT_GAIN]     = {"dB", 1,  1,   0,  63,  23},
  46     [SOUND_RIGHT_GAIN]    = {"dB", 1,  1,   0,  63,  23},
  47     [SOUND_MIC_GAIN]      = {"dB", 1,  1,   0,  63,   0},
  48 #endif
  49 };
  50
  51 static unsigned short wm8975_regs[WM8975_NUM_REGISTERS] =
  52 {
  53     [LINVOL]   = LINVOL_LZCEN | 23, /* 0dB */
  54     [RINVOL]   = RINVOL_RIVU | RINVOL_RZCEN | 23, /* 0dB */
  55     [DAPCTRL]  = DAPCTRL_DACMU,
  56 /* This reduces the popping noise during codec powerup
  57    noticably, especially with high-impedance loads.
  58    We might want to change this for all targets,
  59    but it has only been tested on iPod Nano 2G so far. */
  60 #ifdef IPOD_NANO2G
  61     [PWRMGMT1] = PWRMGMT1_VMIDSEL_500K | PWRMGMT1_VREF,
  62 #else
  63     [PWRMGMT1] = PWRMGMT1_VMIDSEL_5K | PWRMGMT1_VREF,
  64 #endif
  65     [PWRMGMT2] = PWRMGMT2_DACL | PWRMGMT2_DACR | PWRMGMT2_LOUT1
  66                  | PWRMGMT2_ROUT1 | PWRMGMT2_LOUT2 | PWRMGMT2_ROUT2,
  67 };
  68
  69 static void wm8975_write(int reg, unsigned val)
  70 {
  71     if (WM8975_NUM_REGISTERS > reg) {
  72         wm8975_regs[reg] = val;
  73         wmcodec_write(reg, val);
  74     }
  75 }
  76
  77 static void wm8975_write_and(int reg, unsigned bits)
  78 {
  79     wm8975_write(reg, wm8975_regs[reg] & bits);
  80 }
  81
  82 static void wm8975_write_or(int reg, unsigned bits)
  83 {
  84     wm8975_write(reg, wm8975_regs[reg] | bits);
  85 }
  86
  87 /* convert tenth of dB volume (-730..60) to master volume register value */
  88 int tenthdb2master(int db)
  89 {
  90     /* +6 to -73dB 1dB steps (plus mute == 80levels) 7bits */
  91     /* 1111111 == +6dB  (0x7f) */
  92     /* 1111001 == 0dB   (0x79) */
  93     /* 0110000 == -73dB (0x30 */
  94     /* 0101111..0000000 == mute  (0x2f) */
  95
  96     if (db < VOLUME_MIN) {
  97         return 0x0;
  98     } else {
  99         return((db/10)+73+0x30);
 100     }
 101 }
 102
 103 int sound_val2phys(int setting, int value)
 104 {
 105     int result;
 106
 107     switch(setting)
 108     {
 109 #ifdef HAVE_RECORDING
 110     case SOUND_LEFT_GAIN:
 111     case SOUND_RIGHT_GAIN:
 112         result = ((value - 23) * 15) / 2;
 113         break;
 114     case SOUND_MIC_GAIN:
 115         result = ((value - 23) * 15) / 2 + 200;
 116         break;
 117 #endif
 118     default:
 119         result = value;
 120         break;
 121     }
 122
 123     return result;
 124 }
 125
 126 static void audiohw_mute(bool mute)
 127 {
 128     if (mute) {
 129         /* Set DACMU = 1 to soft-mute the audio DACs. */
 130         wm8975_write_or(DAPCTRL, DAPCTRL_DACMU);
 131     } else {
 132         /* Set DACMU = 0 to soft-un-mute the audio DACs. */
 133         wm8975_write_and(DAPCTRL, ~DAPCTRL_DACMU);
 134     }
 135 }
 136
 137 #define IPOD_PCM_LEVEL 0x65       /* -6dB */
 138
 139 /* This reduces the popping noise during codec powerup
 140    noticably, especially with high-impedance loads.
 141    We might want to change this for all targets,
 142    but it has only been tested on iPod Nano 2G so far. */
 143 #ifdef IPOD_NANO2G
 144 void audiohw_preinit(void)
 145 {
 146     wm8975_write(RESET, RESET_RESET);
 147
 148     wm8975_write(AINTFCE, AINTFCE_MS | AINTFCE_LRP_I2S_RLO
 149                         | AINTFCE_IWL_16BIT | AINTFCE_FORMAT_I2S);
 150
 151     wm8975_write(LOUTMIX1, LOUTMIX1_LD2LO | LOUTMIX1_LI2LOVOL(5));
 152     wm8975_write(ROUTMIX2, ROUTMIX2_RD2RO | ROUTMIX2_RI2ROVOL(5));
 153
 154     wm8975_write(PWRMGMT1, wm8975_regs[PWRMGMT1]);
 155     wm8975_write(PWRMGMT2, wm8975_regs[PWRMGMT2]);
 156 }
 157
 158 void audiohw_postinit(void)
 159 {
 160     wm8975_regs[PWRMGMT1] &= ~PWRMGMT1_VMIDSEL_MASK;
 161     wm8975_regs[PWRMGMT1] |= PWRMGMT1_VMIDSEL_50K;
 162     wm8975_write(PWRMGMT1, wm8975_regs[PWRMGMT1]);
 163     audiohw_mute(false);
 164 }
 165 #else /* !IPOD_NANO2G */
 166 void audiohw_preinit(void)
 167 {
 168     /* POWER UP SEQUENCE */
 169     wm8975_write(RESET, RESET_RESET);
 170
 171     /* 2. Enable Vmid and VREF, quick startup. */
 172     wm8975_write(PWRMGMT1, wm8975_regs[PWRMGMT1]);
 173     sleep(HZ/50);
 174     wm8975_regs[PWRMGMT1] &= ~PWRMGMT1_VMIDSEL_MASK;
 175     wm8975_write(PWRMGMT1, wm8975_regs[PWRMGMT1] | PWRMGMT1_VMIDSEL_50K);
 176
 177     /* 4. Enable DACs, line and headphone output buffers as required. */
 178     wm8975_write(PWRMGMT2, wm8975_regs[PWRMGMT2]);
 179
 180     wm8975_write(AINTFCE, AINTFCE_MS | AINTFCE_LRP_I2S_RLO
 181                         | AINTFCE_IWL_16BIT | AINTFCE_FORMAT_I2S);
 182
 183     wm8975_write(DAPCTRL, wm8975_regs[DAPCTRL] );
 184
 185     /* Set sample rate. */
 186     wm8975_write(SAMPCTRL, WM8975_44100HZ);
 187
 188     /* set the volume to -6dB */
 189     wm8975_write(LOUT1VOL, LOUT1VOL_LO1ZC | IPOD_PCM_LEVEL);
 190     wm8975_write(ROUT1VOL, ROUT1VOL_RO1VU | ROUT1VOL_RO1ZC | IPOD_PCM_LEVEL);
 191
 192     wm8975_write(LOUTMIX1, LOUTMIX1_LD2LO| LOUTMIX1_LI2LOVOL(5));
 193     wm8975_write(LOUTMIX2, LOUTMIX2_RI2LOVOL(5));
 194
 195     wm8975_write(ROUTMIX1, ROUTMIX1_LI2ROVOL(5));
 196     wm8975_write(ROUTMIX2, ROUTMIX2_RD2RO| ROUTMIX2_RI2ROVOL(5));
 197
 198     wm8975_write(MOUTMIX1, 0);
 199     wm8975_write(MOUTMIX2, 0);
 200 }
 201
 202 void audiohw_postinit(void)
 203 {
 204     audiohw_mute(false);
 205 }
 206 #endif
 207
 208 void audiohw_set_master_vol(int vol_l, int vol_r)
 209 {
 210     /* +6 to -73dB 1dB steps (plus mute == 80levels) 7bits */
 211     /* 1111111 == +6dB */
 212     /* 1111001 == 0dB */
 213     /* 0110000 == -73dB */
 214     /* 0101111 == mute (0x2f) */
 215
 216     /* OUT1 */
 217     wm8975_write(LOUT1VOL, LOUT1VOL_LO1ZC | vol_l);
 218     wm8975_write(ROUT1VOL, ROUT1VOL_RO1VU | ROUT1VOL_RO1ZC | vol_r);
 219 }
 220
 221 void audiohw_set_lineout_vol(int vol_l, int vol_r)
 222 {
 223     /* OUT2 */
 224     wm8975_write(LOUT2VOL, LOUT2VOL_LO2ZC | vol_l);
 225     wm8975_write(ROUT2VOL, ROUT2VOL_RO2VU | ROUT2VOL_RO2ZC | vol_r);
 226 }
 227
 228 void audiohw_enable_lineout(bool enable)
 229 {
 230     if (enable) {
 231         /* Enable lineout */
 232         wm8975_regs[PWRMGMT2] |=  (PWRMGMT2_LOUT2 | PWRMGMT2_ROUT2);
 233     } else {
 234         /* Disable lineout */
 235         wm8975_regs[PWRMGMT2] &= ~(PWRMGMT2_LOUT2 | PWRMGMT2_ROUT2);
 236     }
 237     wm8975_write(PWRMGMT2, wm8975_regs[PWRMGMT2]);
 238 }
 239
 240 void audiohw_set_bass(int value)
 241 {
 242     const int regvalues[] = {
 243         11, 10, 10, 9, 8, 8, 0xf, 6, 6, 5, 4, 4, 3, 2, 2, 1
 244     };
 245
 246     if ((value >= -6) && (value <= 9)) {
 247         /* We use linear bass control with 200 Hz cutoff */
 248         wm8975_write(BASSCTRL, regvalues[value + 6] | BASSCTRL_BC);
 249     }
 250 }
 251
 252 void audiohw_set_treble(int value)
 253 {
 254     const int regvalues[] = {
 255         11, 10, 10, 9, 8, 8, 0xf, 6, 6, 5, 4, 4, 3, 2, 2, 1
 256     };
 257
 258     if ((value >= -6) && (value <= 9)) {
 259         /* We use linear treble control with 4 kHz cutoff */
 260         wm8975_write(TREBCTRL, regvalues[value + 6] | TREBCTRL_TC);
 261     }
 262 }
 263
 264 /* Nice shutdown of WM8975 codec */
 265 void audiohw_close(void)
 266 {
 267     audiohw_mute(true);
 268
 269     /* 2. Disable all output buffers. */
 270     wm8975_write(PWRMGMT2, 0x0);
 271
 272     /* 3. Switch off the power supplies. */
 273     wm8975_write(PWRMGMT1, 0x0);
 274 }
 275
 276 /* Note: Disable output before calling this function */
 277 void audiohw_set_frequency(int fsel)
 278 {
 279     (void)fsel;
 280 }
 281
 282 #ifdef HAVE_RECORDING
 283 void audiohw_enable_recording(bool source_mic)
 284 {
 285     wm8975_regs[PWRMGMT1] |= PWRMGMT1_AINL | PWRMGMT1_AINR
 286                            | PWRMGMT1_ADCL | PWRMGMT1_ADCR;
 287     wm8975_write(PWRMGMT1, wm8975_regs[PWRMGMT1]);
 288
 289     /* NOTE: When switching to digital monitoring we will not want
 290      * the DACs disabled. Also the outputs shouldn't be disabled
 291      * when recording from line in (dock connector) - needs testing. */
 292     wm8975_regs[PWRMGMT2] &= ~(PWRMGMT2_LOUT1 | PWRMGMT2_ROUT1
 293                              | PWRMGMT2_LOUT2 | PWRMGMT2_ROUT2);
 294     wm8975_write(PWRMGMT2, wm8975_regs[PWRMGMT2]);
 295
 296     wm8975_write_or(LINVOL, LINVOL_LINMUTE);
 297     wm8975_write_or(RINVOL, RINVOL_RINMUTE);
 298
 299     wm8975_write(ADDCTRL3, ADDCTRL3_VROI);
 300
 301     if (source_mic) {
 302         wm8975_write(ADDCTRL1, ADDCTRL1_VSEL_LOWBIAS | ADDCTRL1_DATSEL_RADC
 303                              | ADDCTRL1_TOEN);
 304         wm8975_write(ADCLPATH, 0);
 305         wm8975_write(ADCRPATH, ADCRPATH_RINSEL_RIN2 | ADCRPATH_RMICBOOST_20dB);
 306     } else {
 307         wm8975_write(ADDCTRL1, ADDCTRL1_VSEL_LOWBIAS | ADDCTRL1_DATSEL_NORMAL
 308                              | ADDCTRL1_TOEN);
 309         wm8975_write(ADCLPATH, ADCLPATH_LINSEL_LIN1 | ADCLPATH_LMICBOOST_OFF);
 310         wm8975_write(ADCRPATH, ADCRPATH_RINSEL_RIN1 | ADCRPATH_RMICBOOST_OFF);
 311     }
 312     wm8975_write_and(LINVOL, ~LINVOL_LINMUTE);
 313     wm8975_write_and(RINVOL, ~RINVOL_RINMUTE);
 314 }
 315
 316 void audiohw_disable_recording(void)
 317 {
 318     /* mute inputs */
 319     wm8975_write_or(LINVOL, LINVOL_LINMUTE);
 320     wm8975_write_or(RINVOL, RINVOL_RINMUTE);
 321
 322     wm8975_write(ADDCTRL3, 0);
 323
 324     wm8975_regs[PWRMGMT2] |= PWRMGMT2_DACL | PWRMGMT2_DACR
 325                            | PWRMGMT2_LOUT1 | PWRMGMT2_ROUT1
 326                            | PWRMGMT2_LOUT2 | PWRMGMT2_ROUT2;
 327     wm8975_write(PWRMGMT2, wm8975_regs[PWRMGMT2]);
 328
 329     wm8975_regs[PWRMGMT1] &= ~(PWRMGMT1_AINL | PWRMGMT1_AINR
 330                                | PWRMGMT1_ADCL | PWRMGMT1_ADCR);
 331     wm8975_write(PWRMGMT1, wm8975_regs[PWRMGMT1]);
 332 }
 333
 334 void audiohw_set_recvol(int left, int right, int type)
 335 {
 336     switch (type)
 337     {
 338     case AUDIO_GAIN_MIC:  /* Mic uses right ADC */
 339         wm8975_regs[RINVOL] &= ~RINVOL_MASK;
 340         wm8975_write_or(RINVOL, left & RINVOL_MASK);
 341         break;
 342     case AUDIO_GAIN_LINEIN:
 343         wm8975_regs[LINVOL] &= ~LINVOL_MASK;
 344         wm8975_write_or(LINVOL, left & LINVOL_MASK);
 345         wm8975_regs[RINVOL] &= ~RINVOL_MASK;
 346         wm8975_write_or(RINVOL, right & RINVOL_MASK);
 347         break;
 348     default:
 349         return;
 350     }
 351 }
 352
 353 void audiohw_set_monitor(bool enable)
 354 {
 355     if (enable) {
 356         /* set volume to 0 dB */
 357         wm8975_regs[LOUTMIX1] &= ~LOUTMIX1_LI2LOVOL_MASK;
 358         wm8975_regs[LOUTMIX1] |=  LOUTMIX1_LI2LOVOL(2);
 359         wm8975_regs[ROUTMIX2] &= ~ROUTMIX2_RI2ROVOL_MASK;
 360         wm8975_regs[ROUTMIX2] |=  ROUTMIX2_RI2ROVOL(2);
 361         /* set mux to line input */
 362         wm8975_write_and(LOUTMIX1, ~LOUTMIX1_LMIXSEL_MASK);
 363         wm8975_write_and(ROUTMIX1, ~ROUTMIX1_RMIXSEL_MASK);
 364         /* enable bypass */
 365         wm8975_write_or(LOUTMIX1, LOUTMIX1_LI2LO);
 366         wm8975_write_or(ROUTMIX2, ROUTMIX2_RI2RO);
 367     } else {
 368         /* disable bypass */
 369         wm8975_write_and(LOUTMIX1, ~LOUTMIX1_LI2LO);
 370         wm8975_write_and(ROUTMIX2, ~ROUTMIX2_RI2RO);
 371     }
 372 }
 373 #endif /* HAVE_RECORDING */