firmware/sound.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 by Linus Nielsen Feltzing
  11  * Copyright (C) 2007 by Christian Gmeiner
  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 <stdbool.h>
  23 #include <stdio.h>
  24 #include "config.h"
  25 #include "sound.h"
  26 #include "logf.h"
  27 #include "system.h"
  28 #ifndef SIMULATOR
  29 #include "i2c.h"
  30 #include "mas.h"
  31 #if CONFIG_CPU == PNX0101
  32 #include "pnx0101.h"
  33 #endif
  34 #include "dac.h"
  35 #if CONFIG_CODEC == SWCODEC
  36 #include "pcm.h"
  37 #endif
  38 #endif
  39
  40 /* TODO
  41  * find a nice way to handle 1.5db steps -> see wm8751 ifdef in sound_set_bass/treble
  42 */
  43
  44 #define ONE_DB 10
  45
  46 #if !defined(VOLUME_MIN) && !defined(VOLUME_MAX)
  47 #warning define for VOLUME_MIN and VOLUME_MAX is missing
  48 #define VOLUME_MIN -700
  49 #define VOLUME_MAX  0
  50 #endif
  51
  52 /* volume/balance/treble/bass interdependency main part */
  53 #define VOLUME_RANGE (VOLUME_MAX - VOLUME_MIN)
  54
  55 #ifndef SIMULATOR
  56 extern bool audio_is_initialized;
  57
  58 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
  59 extern unsigned long shadow_io_control_main;
  60 extern unsigned shadow_codec_reg0;
  61 #endif
  62 #endif /* SIMULATOR */
  63
  64 #ifdef SIMULATOR
  65 /* dummy for sim */
  66 const struct sound_settings_info audiohw_settings[] = {
  67     [SOUND_VOLUME]        = {"dB", 0,  1, VOLUME_MIN / 10, VOLUME_MAX / 10, -25},
  68     [SOUND_BASS]          = {"dB", 0,  1, -24,  24,   0},
  69     [SOUND_TREBLE]        = {"dB", 0,  1, -24,  24,   0},
  70     [SOUND_BALANCE]       = {"%",  0,  1,-100, 100,   0},
  71     [SOUND_CHANNELS]      = {"",   0,  1,   0,   5,   0},
  72     [SOUND_STEREO_WIDTH]  = {"%",  0,  5,   0, 250, 100},
  73 #if defined(HAVE_RECORDING)
  74     [SOUND_LEFT_GAIN]     = {"dB", 1,  1,-128,  96,   0},
  75     [SOUND_RIGHT_GAIN]    = {"dB", 1,  1,-128,  96,   0},
  76     [SOUND_MIC_GAIN]      = {"dB", 1,  1,-128, 108,  16},
  77 #endif
  78 #if defined(AUDIOHW_HAVE_BASS_CUTOFF)
  79     [SOUND_BASS_CUTOFF]   = {"",   0,  1,   1,   4,   1},
  80 #endif
  81 #if defined(AUDIOHW_HAVE_TREBLE_CUTOFF)
  82     [SOUND_TREBLE_CUTOFF] = {"",   0,  1,   1,   4,   1},
  83 #endif
  84 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
  85     [SOUND_LOUDNESS]      = {"dB", 0,  1,   0,  17,   0},
  86     [SOUND_AVC]           = {"",   0,  1,  -1,   4,   0},
  87     [SOUND_MDB_STRENGTH]  = {"dB", 0,  1,   0, 127,  48},
  88     [SOUND_MDB_HARMONICS] = {"%",  0,  1,   0, 100,  50},
  89     [SOUND_MDB_CENTER]    = {"Hz", 0, 10,  20, 300,  60},
  90     [SOUND_MDB_SHAPE]     = {"Hz", 0, 10,  50, 300,  90},
  91     [SOUND_MDB_ENABLE]    = {"",   0,  1,   0,   1,   0},
  92     [SOUND_SUPERBASS]     = {"",   0,  1,   0,   1,   0},
  93 #endif
  94 };
  95 #endif
  96
  97 const char *sound_unit(int setting)
  98 {
  99     return audiohw_settings[setting].unit;
 100 }
 101
 102 int sound_numdecimals(int setting)
 103 {
 104     return audiohw_settings[setting].numdecimals;
 105 }
 106
 107 int sound_steps(int setting)
 108 {
 109     return audiohw_settings[setting].steps;
 110 }
 111
 112 int sound_min(int setting)
 113 {
 114     return audiohw_settings[setting].minval;
 115 }
 116
 117 int sound_max(int setting)
 118 {
 119     return audiohw_settings[setting].maxval;
 120 }
 121
 122 int sound_default(int setting)
 123 {
 124     return audiohw_settings[setting].defaultval;
 125 }
 126
 127 static sound_set_type *sound_set_fns[] =
 128 {
 129     [0 ... SOUND_LAST_SETTING-1] = NULL,
 130     [SOUND_VOLUME]        = sound_set_volume,
 131     [SOUND_BASS]          = sound_set_bass,
 132     [SOUND_TREBLE]        = sound_set_treble,
 133     [SOUND_BALANCE]       = sound_set_balance,
 134     [SOUND_CHANNELS]      = sound_set_channels,
 135     [SOUND_STEREO_WIDTH]  = sound_set_stereo_width,
 136 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 137     [SOUND_LOUDNESS]      = sound_set_loudness,
 138     [SOUND_AVC]           = sound_set_avc,
 139     [SOUND_MDB_STRENGTH]  = sound_set_mdb_strength,
 140     [SOUND_MDB_HARMONICS] = sound_set_mdb_harmonics,
 141     [SOUND_MDB_CENTER]    = sound_set_mdb_center,
 142     [SOUND_MDB_SHAPE]     = sound_set_mdb_shape,
 143     [SOUND_MDB_ENABLE]    = sound_set_mdb_enable,
 144     [SOUND_SUPERBASS]     = sound_set_superbass,
 145 #endif
 146 #if defined(AUDIOHW_HAVE_BASS_CUTOFF)
 147     [SOUND_BASS_CUTOFF]   = sound_set_bass_cutoff,
 148 #endif
 149 #if defined(AUDIOHW_HAVE_TREBLE_CUTOFF)
 150     [SOUND_TREBLE_CUTOFF] = sound_set_treble_cutoff,
 151 #endif
 152 };
 153
 154 sound_set_type* sound_get_fn(int setting)
 155 {
 156     return ((unsigned)setting >= ARRAYLEN(sound_set_fns)?
 157                 NULL : sound_set_fns[setting]);
 158 }
 159
 160 #if CONFIG_CODEC == SWCODEC
 161 /* Copied from dsp.h, nasty nasty, but we don't want to include dsp.h */
 162 enum {
 163     DSP_CALLBACK_SET_PRESCALE = 0,
 164     DSP_CALLBACK_SET_BASS,
 165     DSP_CALLBACK_SET_TREBLE,
 166     DSP_CALLBACK_SET_CHANNEL_CONFIG,
 167     DSP_CALLBACK_SET_STEREO_WIDTH
 168 };
 169
 170 static int (*dsp_callback)(int, intptr_t) = NULL;
 171
 172 void sound_set_dsp_callback(int (*func)(int, intptr_t))
 173 {
 174     dsp_callback = func;
 175 }
 176 #endif
 177
 178 #ifndef SIMULATOR
 179 #if CONFIG_CODEC == MAS3507D
 180 /* convert tenth of dB volume (-780..+180) to dac3550 register value */
 181 static int tenthdb2reg(int db)
 182 {
 183     if (db < -540)                  /* 3 dB steps */
 184         return (db + 780) / 30;
 185     else                            /* 1.5 dB steps */
 186         return (db + 660) / 15;
 187 }
 188 #endif
 189
 190
 191 #if !defined(AUDIOHW_HAVE_CLIPPING)
 192 /*
 193  * The prescaler compensates for any kind of boosts, to prevent clipping.
 194  *
 195  * It's basically just a measure to make sure that audio does not clip during
 196  * tone controls processing, like if i want to boost bass 12 dB, i can decrease
 197  * the audio amplitude by -12 dB before processing, then increase master gain
 198  * by 12 dB after processing.
 199  */
 200
 201 /* all values in tenth of dB    MAS3507D    UDA1380  */
 202 int current_volume = 0;    /* -780..+180  -840..   0 */
 203 int current_balance = 0;   /* -960..+960  -840..+840 */
 204 int current_treble = 0;    /* -150..+150     0.. +60 */
 205 int current_bass = 0;      /* -150..+150     0..+240 */
 206
 207 static void set_prescaled_volume(void)
 208 {
 209     int prescale = 0;
 210     int l, r;
 211
 212 /* The WM codecs listed don't have suitable prescaler functionality, so we let
 213  * the prescaler stay at 0 for these unless SW tone controls are in use */
 214 #if defined(HAVE_SW_TONE_CONTROLS) || !(defined(HAVE_WM8975) \
 215     || defined(HAVE_WM8711) || defined(HAVE_WM8721) || defined(HAVE_WM8731) \
 216     || defined(HAVE_WM8751) || defined(HAVE_WM8758) || defined(HAVE_WM8985)) \
 217     || defined(HAVE_TSC2100)
 218
 219     prescale = MAX(current_bass, current_treble);
 220     if (prescale < 0)
 221         prescale = 0;  /* no need to prescale if we don't boost
 222                           bass or treble */
 223
 224     /* Gain up the analog volume to compensate the prescale gain reduction,
 225      * but if this would push the volume over the top, reduce prescaling
 226      * instead (might cause clipping). */
 227     if (current_volume + prescale > VOLUME_MAX)
 228         prescale = VOLUME_MAX - current_volume;
 229 #endif
 230
 231 #if defined(AUDIOHW_HAVE_PRESCALER)
 232     audiohw_set_prescaler(prescale);
 233 #else
 234     dsp_callback(DSP_CALLBACK_SET_PRESCALE, prescale);
 235 #endif
 236
 237     if (current_volume == VOLUME_MIN)
 238         prescale = 0;  /* Make sure the chip gets muted at VOLUME_MIN */
 239
 240     l = r = current_volume + prescale;
 241
 242     /* Balance the channels scaled by the current volume and min volume. */
 243     /* Subtract a dB from VOLUME_MIN to get it to a mute level */
 244     if (current_balance > 0)
 245     {
 246         l -= ((l - (VOLUME_MIN - ONE_DB)) * current_balance) / VOLUME_RANGE;
 247     }
 248     else if (current_balance < 0)
 249     {
 250         r += ((r - (VOLUME_MIN - ONE_DB)) * current_balance) / VOLUME_RANGE;
 251     }
 252
 253 #if CONFIG_CODEC == MAS3507D
 254     dac_volume(tenthdb2reg(l), tenthdb2reg(r), false);
 255 #elif defined(HAVE_UDA1380) || defined(HAVE_WM8975) || defined(HAVE_WM8758) \
 256    || defined(HAVE_WM8711) || defined(HAVE_WM8721) || defined(HAVE_WM8731) \
 257    || defined(HAVE_WM8751) || defined(HAVE_AS3514) || defined(HAVE_TSC2100) \
 258    || defined(HAVE_AK4537)
 259     audiohw_set_master_vol(tenthdb2master(l), tenthdb2master(r));
 260 #if defined(HAVE_WM8975) || defined(HAVE_WM8758) \
 261         || (defined(HAVE_WM8751) && !defined(MROBE_100)) || defined(HAVE_WM8985)
 262     audiohw_set_lineout_vol(tenthdb2master(0), tenthdb2master(0));
 263 #endif
 264
 265 #elif defined(HAVE_TLV320) || defined(HAVE_WM8978) || defined(HAVE_WM8985)
 266     audiohw_set_headphone_vol(tenthdb2master(l), tenthdb2master(r));
 267 #elif defined(HAVE_JZ4740_CODEC)
 268     audiohw_set_volume(current_volume);
 269 #endif
 270 }
 271 #endif /* (CONFIG_CODEC == MAS3507D) || defined HAVE_UDA1380 */
 272 #endif /* !SIMULATOR */
 273
 274
 275 #ifndef SIMULATOR
 276
 277 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 278 unsigned long mdb_shape_shadow = 0;
 279 unsigned long loudness_shadow = 0;
 280 #endif
 281
 282 void sound_set_volume(int value)
 283 {
 284     if(!audio_is_initialized)
 285         return;
 286
 287 #if defined(AUDIOHW_HAVE_CLIPPING)
 288     audiohw_set_volume(value);
 289 #elif CONFIG_CPU == PNX0101
 290     int tmp = (60 - value * 4) & 0xff;
 291     CODECVOL = tmp | (tmp << 8);
 292 #else
 293     current_volume = value * 10;     /* tenth of dB */
 294     set_prescaled_volume();
 295 #endif
 296 }
 297
 298 void sound_set_balance(int value)
 299 {
 300     if(!audio_is_initialized)
 301         return;
 302
 303 #ifdef AUDIOHW_HAVE_BALANCE
 304     audiohw_set_balance(value);
 305 #else
 306     current_balance = value * VOLUME_RANGE / 100; /* tenth of dB */
 307     set_prescaled_volume();
 308 #endif
 309 }
 310
 311 void sound_set_bass(int value)
 312 {
 313     if(!audio_is_initialized)
 314         return;
 315
 316 #if !defined(AUDIOHW_HAVE_CLIPPING)
 317 #if defined(HAVE_WM8751)
 318     current_bass = value;
 319 #else
 320     current_bass =  value * 10;
 321 #endif
 322 #endif
 323
 324 #if defined(AUDIOHW_HAVE_BASS)
 325     audiohw_set_bass(value);
 326 #else
 327     dsp_callback(DSP_CALLBACK_SET_BASS, current_bass);
 328 #endif
 329
 330 #if !defined(AUDIOHW_HAVE_CLIPPING)
 331     set_prescaled_volume();
 332 #endif
 333 }
 334
 335 void sound_set_treble(int value)
 336 {
 337     if(!audio_is_initialized)
 338         return;
 339
 340 #if !defined(AUDIOHW_HAVE_CLIPPING)
 341 #if defined(HAVE_WM8751)
 342     current_treble = value;
 343 #else
 344     current_treble =  value * 10;
 345 #endif
 346 #endif
 347
 348 #if defined(AUDIOHW_HAVE_TREBLE)
 349     audiohw_set_treble(value);
 350 #else
 351     dsp_callback(DSP_CALLBACK_SET_TREBLE, current_treble);
 352 #endif
 353
 354 #if !defined(AUDIOHW_HAVE_CLIPPING)
 355     set_prescaled_volume();
 356 #endif
 357 }
 358
 359 void sound_set_channels(int value)
 360 {
 361     if(!audio_is_initialized)
 362         return;
 363
 364 #if CONFIG_CODEC == SWCODEC
 365     dsp_callback(DSP_CALLBACK_SET_CHANNEL_CONFIG, value);
 366 #else
 367     audiohw_set_channel(value);
 368 #endif
 369 }
 370
 371 void sound_set_stereo_width(int value)
 372 {
 373     if(!audio_is_initialized)
 374         return;
 375
 376 #if CONFIG_CODEC == SWCODEC
 377     dsp_callback(DSP_CALLBACK_SET_STEREO_WIDTH, value);
 378 #else
 379     audiohw_set_stereo_width(value);
 380 #endif
 381 }
 382
 383 #if defined(AUDIOHW_HAVE_BASS_CUTOFF)
 384 void sound_set_bass_cutoff(int value)
 385 {
 386     if(!audio_is_initialized)
 387         return;
 388
 389     audiohw_set_bass_cutoff(value);
 390 }
 391 #endif
 392
 393 #if defined(AUDIOHW_HAVE_TREBLE_CUTOFF)
 394 void sound_set_treble_cutoff(int value)
 395 {
 396     if(!audio_is_initialized)
 397         return;
 398
 399     audiohw_set_treble_cutoff(value);
 400 }
 401 #endif
 402
 403 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 404 void sound_set_loudness(int value)
 405 {
 406     if(!audio_is_initialized)
 407         return;
 408     loudness_shadow = (loudness_shadow & 0x04) |
 409                        (MAX(MIN(value * 4, 0x44), 0) << 8);
 410     mas_codec_writereg(MAS_REG_KLOUDNESS, loudness_shadow);
 411 }
 412
 413 void sound_set_avc(int value)
 414 {
 415     if(!audio_is_initialized)
 416         return;
 417     int tmp;
 418
 419     static const uint16_t avc_vals[] =
 420     {
 421         (0x1 << 8) | (0x8 << 12), /* 20ms */
 422         (0x2 << 8) | (0x8 << 12), /* 2s */
 423         (0x4 << 8) | (0x8 << 12), /* 4s */
 424         (0x8 << 8) | (0x8 << 12), /* 8s */
 425     };
 426     switch (value) {
 427         case 1:
 428         case 2:
 429         case 3:
 430         case 4:
 431             tmp = avc_vals[value -1];
 432             break;
 433         case -1: /* turn off and then turn on again to decay quickly */
 434             tmp = mas_codec_readreg(MAS_REG_KAVC);
 435             mas_codec_writereg(MAS_REG_KAVC, 0);
 436             break;
 437         default: /* off */
 438             tmp = 0;
 439             break;
 440     }
 441     mas_codec_writereg(MAS_REG_KAVC, tmp);
 442 }
 443
 444 void sound_set_mdb_strength(int value)
 445 {
 446     if(!audio_is_initialized)
 447         return;
 448     mas_codec_writereg(MAS_REG_KMDB_STR, (value & 0x7f) << 8);
 449 }
 450
 451 void sound_set_mdb_harmonics(int value)
 452 {
 453     if(!audio_is_initialized)
 454         return;
 455     int tmp = value * 127 / 100;
 456     mas_codec_writereg(MAS_REG_KMDB_HAR, (tmp & 0x7f) << 8);
 457 }
 458
 459 void sound_set_mdb_center(int value)
 460 {
 461     if(!audio_is_initialized)
 462         return;
 463     mas_codec_writereg(MAS_REG_KMDB_FC, (value/10) << 8);
 464 }
 465
 466 void sound_set_mdb_shape(int value)
 467 {
 468     if(!audio_is_initialized)
 469         return;
 470     mdb_shape_shadow = (mdb_shape_shadow & 0x02) | ((value/10) << 8);
 471     mas_codec_writereg(MAS_REG_KMDB_SWITCH, mdb_shape_shadow);
 472 }
 473
 474 void sound_set_mdb_enable(int value)
 475 {
 476     if(!audio_is_initialized)
 477         return;
 478     mdb_shape_shadow = (mdb_shape_shadow & ~0x02) | (value?2:0);
 479     mas_codec_writereg(MAS_REG_KMDB_SWITCH, mdb_shape_shadow);
 480 }
 481
 482 void sound_set_superbass(int value)
 483 {
 484     if(!audio_is_initialized)
 485         return;
 486     loudness_shadow = (loudness_shadow & ~0x04) | (value?4:0);
 487     mas_codec_writereg(MAS_REG_KLOUDNESS, loudness_shadow);
 488 }
 489 #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */
 490
 491 #else /* SIMULATOR */
 492 int sim_volume;
 493 void sound_set_volume(int value)
 494 {
 495     /* 128 is SDL_MIX_MAXVOLUME */
 496     sim_volume = 128 * (value - VOLUME_MIN / 10) / (VOLUME_RANGE / 10);
 497 }
 498
 499 void sound_set_balance(int value)
 500 {
 501     (void)value;
 502 }
 503
 504 void sound_set_bass(int value)
 505 {
 506     (void)value;
 507 }
 508
 509 void sound_set_treble(int value)
 510 {
 511     (void)value;
 512 }
 513
 514 void sound_set_channels(int value)
 515 {
 516     (void)value;
 517 }
 518
 519 void sound_set_stereo_width(int value)
 520 {
 521     (void)value;
 522 }
 523
 524 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 525 void sound_set_loudness(int value)
 526 {
 527     (void)value;
 528 }
 529
 530 void sound_set_avc(int value)
 531 {
 532     (void)value;
 533 }
 534
 535 void sound_set_mdb_strength(int value)
 536 {
 537     (void)value;
 538 }
 539
 540 void sound_set_mdb_harmonics(int value)
 541 {
 542     (void)value;
 543 }
 544
 545 void sound_set_mdb_center(int value)
 546 {
 547     (void)value;
 548 }
 549
 550 void sound_set_mdb_shape(int value)
 551 {
 552     (void)value;
 553 }
 554
 555 void sound_set_mdb_enable(int value)
 556 {
 557     (void)value;
 558 }
 559
 560 void sound_set_superbass(int value)
 561 {
 562     (void)value;
 563 }
 564 #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */
 565
 566 #if defined(HAVE_WM8758) || defined(HAVE_WM8985)
 567 void sound_set_bass_cutoff(int value)
 568 {
 569     (void) value;
 570 }
 571
 572 void sound_set_treble_cutoff(int value)
 573 {
 574     (void) value;
 575 }
 576 #endif /* HAVE_WM8758 */
 577
 578 #endif /* SIMULATOR */
 579
 580 void sound_set(int setting, int value)
 581 {
 582     sound_set_type* sound_set_val = sound_get_fn(setting);
 583     if (sound_set_val)
 584         sound_set_val(value);
 585 }
 586
 587 #if (!defined(HAVE_AS3514) && !defined(HAVE_WM8975) \
 588   && !defined(HAVE_WM8758) && !defined(HAVE_TSC2100) \
 589   && !defined (HAVE_WM8711) && !defined (HAVE_WM8721) \
 590   && !defined (HAVE_WM8731) && !defined (HAVE_WM8978) \
 591   && !defined(HAVE_AK4537)) || defined(SIMULATOR)
 592 int sound_val2phys(int setting, int value)
 593 {
 594 #if CONFIG_CODEC == MAS3587F
 595     int result = 0;
 596
 597     switch(setting)
 598     {
 599         case SOUND_LEFT_GAIN:
 600         case SOUND_RIGHT_GAIN:
 601             result = (value - 2) * 15;
 602             break;
 603
 604         case SOUND_MIC_GAIN:
 605             result = value * 15 + 210;
 606             break;
 607
 608        default:
 609             result = value;
 610             break;
 611     }
 612     return result;
 613 #elif defined(HAVE_UDA1380)
 614     int result = 0;
 615
 616     switch(setting)
 617     {
 618 #ifdef HAVE_RECORDING
 619         case SOUND_LEFT_GAIN:
 620         case SOUND_RIGHT_GAIN:
 621         case SOUND_MIC_GAIN:
 622             result = value * 5;         /* (1/2) * 10 */
 623             break;
 624 #endif
 625         default:
 626             result = value;
 627             break;
 628     }
 629     return result;
 630 #elif defined(HAVE_TLV320) || defined(HAVE_WM8711) \
 631       || defined(HAVE_WM8721) || defined(HAVE_WM8731)
 632     int result = 0;
 633
 634     switch(setting)
 635     {
 636 #ifdef HAVE_RECORDING
 637         case SOUND_LEFT_GAIN:
 638         case SOUND_RIGHT_GAIN:
 639             result = (value - 23) * 15;    /* (x - 23)/1.5 *10 */
 640             break;
 641
 642         case SOUND_MIC_GAIN:
 643             result = value * 200;          /* 0 or 20 dB */
 644             break;
 645 #endif
 646        default:
 647             result = value;
 648             break;
 649     }
 650     return result;
 651 #elif defined(HAVE_AS3514)
 652     /* This is here for the sim only and the audio driver has its own */
 653     int result;
 654
 655     switch(setting)
 656     {
 657 #ifdef HAVE_RECORDING
 658     case SOUND_LEFT_GAIN:
 659     case SOUND_RIGHT_GAIN:
 660     case SOUND_MIC_GAIN:
 661         result = (value - 23) * 15;
 662         break;
 663 #endif
 664     default:
 665         result = value;
 666         break;
 667     }
 668
 669     return result;
 670 #elif defined(HAVE_WM8978)
 671     int result;
 672
 673     switch (setting)
 674     {
 675 #ifdef HAVE_RECORDING
 676     case SOUND_LEFT_GAIN:
 677     case SOUND_RIGHT_GAIN:
 678     case SOUND_MIC_GAIN:
 679         result = value * 5;
 680         break;
 681 #endif
 682
 683     default:
 684         result = value;
 685     }
 686
 687     return result;
 688 #else
 689     (void)setting;
 690     return value;
 691 #endif
 692 }
 693 #endif /* !defined(HAVE_AS3514) || defined(SIMULATOR) */
 694
 695 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 696 #ifndef SIMULATOR
 697 /* This function works by telling the decoder that we have another
 698    crystal frequency than we actually have. It will adjust its internal
 699    parameters and the result is that the audio is played at another pitch.
 700
 701    The pitch value is in tenths of percent.
 702 */
 703 static int last_pitch = 1000;
 704
 705 void sound_set_pitch(int pitch)
 706 {
 707     unsigned long val;
 708
 709     if (pitch != last_pitch)
 710     {
 711         /* Calculate the new (bogus) frequency */
 712         val = 18432 * 1000 / pitch;
 713
 714         mas_writemem(MAS_BANK_D0, MAS_D0_OFREQ_CONTROL, &val, 1);
 715
 716         /* We must tell the MAS that the frequency has changed.
 717          * This will unfortunately cause a short silence. */
 718         mas_writemem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &shadow_io_control_main, 1);
 719
 720         last_pitch = pitch;
 721     }
 722 }
 723
 724 int sound_get_pitch(void)
 725 {
 726     return last_pitch;
 727 }
 728 #else /* SIMULATOR */
 729 void sound_set_pitch(int pitch)
 730 {
 731     (void)pitch;
 732 }
 733
 734 int sound_get_pitch(void)
 735 {
 736     return 1000;
 737 }
 738 #endif /* SIMULATOR */
 739 #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */