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  * All files in this archive are subject to the GNU General Public License.
  14  * See the file COPYING in the source tree root for full license agreement.
  15  *
  16  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  17  * KIND, either express or implied.
  18  *
  19  ****************************************************************************/
  20 #include <stdbool.h>
  21 #include <stdio.h>
  22 #include "config.h"
  23 #include "sound.h"
  24 #include "logf.h"
  25 #ifndef SIMULATOR
  26 #include "i2c.h"
  27 #include "mas.h"
  28 #if CONFIG_CPU == PNX0101
  29 #include "pnx0101.h"
  30 #endif
  31 #include "dac.h"
  32 #include "system.h"
  33 #if CONFIG_CODEC == SWCODEC
  34 #include "pcm.h"
  35 #endif
  36 #endif
  37
  38 #if CONFIG_CODEC == MAS3507D /* volume/balance/treble/bass interdependency */
  39 #define VOLUME_MIN -780
  40 #define VOLUME_MAX  180
  41 #elif !defined(VOLUME_MIN) && !defined(VOLUME_MAX)
  42 #define VOLUME_MIN -400
  43 #define VOLUME_MAX  600
  44 #endif
  45
  46 /* volume/balance/treble/bass interdependency main part */
  47 #define VOLUME_RANGE (VOLUME_MAX - VOLUME_MIN)
  48
  49 #ifndef SIMULATOR
  50 extern bool audio_is_initialized;
  51
  52 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
  53 extern unsigned long shadow_io_control_main;
  54 extern unsigned shadow_codec_reg0;
  55 #endif
  56 #endif /* SIMULATOR */
  57
  58 #ifdef SIMULATOR
  59 /* dummy for sim */
  60 const struct sound_settings_info audiohw_settings[] = {
  61     [SOUND_VOLUME]        = {"dB", 0,  1, VOLUME_MIN / 10, VOLUME_MAX / 10, -25},
  62     [SOUND_BASS]          = {"dB", 0,  1, -24,  24,   0},
  63     [SOUND_TREBLE]        = {"dB", 0,  1, -24,  24,   0},
  64     [SOUND_BALANCE]       = {"%",  0,  1,-100, 100,   0},
  65     [SOUND_CHANNELS]      = {"",   0,  1,   0,   5,   0},
  66     [SOUND_STEREO_WIDTH]  = {"%",  0,  5,   0, 250, 100},
  67 #if CONFIG_CODEC == MAS3587F || defined(HAVE_UDA1380) || defined(HAVE_TLV320)\
  68     || defined(HAVE_WM8975) || defined(HAVE_WM8758) || defined(HAVE_WM8731)
  69     [SOUND_LEFT_GAIN]     = {"dB", 1,  1,-128,  96,   0},
  70     [SOUND_RIGHT_GAIN]    = {"dB", 1,  1,-128,  96,   0},
  71     [SOUND_MIC_GAIN]      = {"dB", 1,  1,-128, 108,  16},
  72 #endif
  73 #if defined(HAVE_WM8758)
  74     [SOUND_BASS_CUTOFF]   = {"",   0,  1,   1,   4,   1},
  75     [SOUND_TREBLE_CUTOFF] = {"",   0,  1,   1,   4,   1},
  76 #endif
  77 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
  78     [SOUND_LOUDNESS]      = {"dB", 0,  1,   0,  17,   0},
  79     [SOUND_AVC]           = {"",   0,  1,  -1,   4,   0},
  80     [SOUND_MDB_STRENGTH]  = {"dB", 0,  1,   0, 127,  48},
  81     [SOUND_MDB_HARMONICS] = {"%",  0,  1,   0, 100,  50},
  82     [SOUND_MDB_CENTER]    = {"Hz", 0, 10,  20, 300,  60},
  83     [SOUND_MDB_SHAPE]     = {"Hz", 0, 10,  50, 300,  90},
  84     [SOUND_MDB_ENABLE]    = {"",   0,  1,   0,   1,   0},
  85     [SOUND_SUPERBASS]     = {"",   0,  1,   0,   1,   0},
  86 #endif
  87 };
  88 #endif
  89
  90 const char *sound_unit(int setting)
  91 {
  92     return audiohw_settings[setting].unit;
  93 }
  94
  95 int sound_numdecimals(int setting)
  96 {
  97     return audiohw_settings[setting].numdecimals;
  98 }
  99
 100 int sound_steps(int setting)
 101 {
 102     return audiohw_settings[setting].steps;
 103 }
 104
 105 int sound_min(int setting)
 106 {
 107     return audiohw_settings[setting].minval;
 108 }
 109
 110 int sound_max(int setting)
 111 {
 112     return audiohw_settings[setting].maxval;
 113 }
 114
 115 int sound_default(int setting)
 116 {
 117     return audiohw_settings[setting].defaultval;
 118 }
 119
 120 sound_set_type* sound_get_fn(int setting)
 121 {
 122     sound_set_type* result = NULL;
 123
 124     switch (setting) {
 125         case SOUND_VOLUME:
 126             result = sound_set_volume;
 127             break;
 128
 129         case SOUND_BASS:
 130             result = sound_set_bass;
 131             break;
 132
 133         case SOUND_TREBLE:
 134             result = sound_set_treble;
 135             break;
 136
 137         case SOUND_BALANCE:
 138             result = sound_set_balance;
 139             break;
 140
 141         case SOUND_CHANNELS:
 142             result = sound_set_channels;
 143             break;
 144
 145         case SOUND_STEREO_WIDTH:
 146             result = sound_set_stereo_width;
 147             break;
 148
 149 #ifdef HAVE_WM8758
 150         case SOUND_BASS_CUTOFF:
 151             result = sound_set_bass_cutoff;
 152             break;
 153
 154         case SOUND_TREBLE_CUTOFF:
 155             result = sound_set_treble_cutoff;
 156             break;
 157 #endif
 158
 159 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 160         case SOUND_LOUDNESS:
 161             result = sound_set_loudness;
 162             break;
 163
 164         case SOUND_AVC:
 165             result = sound_set_avc;
 166             break;
 167
 168         case SOUND_MDB_STRENGTH:
 169             result = sound_set_mdb_strength;
 170             break;
 171
 172         case SOUND_MDB_HARMONICS:
 173             result = sound_set_mdb_harmonics;
 174             break;
 175
 176         case SOUND_MDB_CENTER:
 177             result = sound_set_mdb_center;
 178             break;
 179
 180         case SOUND_MDB_SHAPE:
 181             result = sound_set_mdb_shape;
 182             break;
 183
 184         case SOUND_MDB_ENABLE:
 185             result = sound_set_mdb_enable;
 186             break;
 187
 188         case SOUND_SUPERBASS:
 189             result = sound_set_superbass;
 190             break;
 191 #endif
 192     }
 193
 194     return result;
 195 }
 196
 197 #if CONFIG_CODEC == SWCODEC
 198 /* Copied from dsp.h, nasty nasty, but we don't want to include dsp.h */
 199 enum {
 200     DSP_CALLBACK_SET_PRESCALE = 0,
 201     DSP_CALLBACK_SET_BASS,
 202     DSP_CALLBACK_SET_TREBLE,
 203     DSP_CALLBACK_SET_CHANNEL_CONFIG,
 204     DSP_CALLBACK_SET_STEREO_WIDTH
 205 };
 206
 207 static int (*dsp_callback)(int, intptr_t) = NULL;
 208
 209 void sound_set_dsp_callback(int (*func)(int, intptr_t))
 210 {
 211     dsp_callback = func;
 212 }
 213 #endif
 214
 215 #ifndef SIMULATOR
 216 #if CONFIG_CODEC == MAS3507D
 217 /* convert tenth of dB volume (-780..+180) to dac3550 register value */
 218 static int tenthdb2reg(int db)
 219 {
 220     if (db < -540)                  /* 3 dB steps */
 221         return (db + 780) / 30;
 222     else                            /* 1.5 dB steps */
 223         return (db + 660) / 15;
 224 }
 225 #endif
 226
 227 #if (CONFIG_CODEC == MAS3507D) || defined HAVE_UDA1380 \
 228     || defined HAVE_WM8975 || defined HAVE_WM8758 || defined(HAVE_WM8731) \
 229     || defined(HAVE_WM8721) || defined(HAVE_TLV320) || defined(HAVE_WM8751) \
 230     || defined(HAVE_AS3514)
 231
 232 /* all values in tenth of dB    MAS3507D    UDA1380  */
 233 int current_volume = 0;    /* -780..+180  -840..   0 */
 234 int current_balance = 0;   /* -960..+960  -840..+840 */
 235 int current_treble = 0;    /* -150..+150     0.. +60 */
 236 int current_bass = 0;      /* -150..+150     0..+240 */
 237
 238 static void set_prescaled_volume(void)
 239 {
 240     int prescale = 0;
 241     int l, r;
 242
 243 /* The WM codecs listed don't have suitable prescaler functionality, so we let
 244  * the prescaler stay at 0 for these unless SW tone controls are in use */
 245 #if defined(HAVE_SW_TONE_CONTROLS) || !(defined(HAVE_WM8975) \
 246     || defined(HAVE_WM8731) || defined(HAVE_WM8721) || defined(HAVE_WM8751) \
 247     || defined(HAVE_WM8758))
 248
 249     prescale = MAX(current_bass, current_treble);
 250     if (prescale < 0)
 251         prescale = 0;  /* no need to prescale if we don't boost
 252                           bass or treble */
 253
 254     /* Gain up the analog volume to compensate the prescale gain reduction,
 255      * but if this would push the volume over the top, reduce prescaling
 256      * instead (might cause clipping). */
 257     if (current_volume + prescale > VOLUME_MAX)
 258         prescale = VOLUME_MAX - current_volume;
 259 #endif
 260
 261 #if defined(HAVE_SW_TONE_CONTROLS)
 262     dsp_callback(DSP_CALLBACK_SET_PRESCALE, prescale);
 263 #elif CONFIG_CODEC == MAS3507D
 264     mas_writereg(MAS_REG_KPRESCALE, prescale_table[prescale/10]);
 265 #elif defined(HAVE_UDA1380)
 266     audiohw_set_mixer_vol(tenthdb2mixer(-prescale), tenthdb2mixer(-prescale));
 267 #endif
 268
 269     if (current_volume == VOLUME_MIN)
 270         prescale = 0;  /* Make sure the chip gets muted at VOLUME_MIN */
 271
 272     l = r = current_volume + prescale;
 273
 274     if (current_balance > 0)
 275     {
 276         l -= current_balance;
 277         if (l < VOLUME_MIN)
 278             l = VOLUME_MIN;
 279     }
 280     if (current_balance < 0)
 281     {
 282         r += current_balance;
 283         if (r < VOLUME_MIN)
 284             r = VOLUME_MIN;
 285     }
 286
 287 #if CONFIG_CODEC == MAS3507D
 288     dac_volume(tenthdb2reg(l), tenthdb2reg(r), false);
 289 #elif defined(HAVE_UDA1380) || defined(HAVE_WM8975) || defined(HAVE_WM8758) \
 290    || defined(HAVE_WM8731) || defined(HAVE_WM8721) || defined(HAVE_WM8751) \
 291    || defined(HAVE_AS3514)
 292     audiohw_set_master_vol(tenthdb2master(l), tenthdb2master(r));
 293 #if defined(HAVE_WM8975) || defined(HAVE_WM8758) \
 294    || (defined(HAVE_WM8751) && !defined(MROBE_100))
 295     audiohw_set_lineout_vol(tenthdb2master(0), tenthdb2master(0));
 296 #endif
 297
 298 #elif defined(HAVE_TLV320)
 299     audiohw_set_headphone_vol(tenthdb2master(l), tenthdb2master(r));
 300 #endif
 301 }
 302 #endif /* (CONFIG_CODEC == MAS3507D) || defined HAVE_UDA1380 */
 303 #endif /* !SIMULATOR */
 304
 305 #if CONFIG_CODEC != SWCODEC
 306 int channel_configuration = SOUND_CHAN_STEREO;
 307 int stereo_width = 100;
 308 #endif
 309
 310 #ifndef SIMULATOR
 311
 312 #if CONFIG_CODEC != SWCODEC
 313 static void set_channel_config(void)
 314 {
 315     /* default values: stereo */
 316     unsigned long val_ll = 0x80000;
 317     unsigned long val_lr = 0;
 318     unsigned long val_rl = 0;
 319     unsigned long val_rr = 0x80000;
 320
 321     switch(channel_configuration)
 322     {
 323         /* case SOUND_CHAN_STEREO unnecessary */
 324
 325         case SOUND_CHAN_MONO:
 326             val_ll = 0xc0000;
 327             val_lr = 0xc0000;
 328             val_rl = 0xc0000;
 329             val_rr = 0xc0000;
 330             break;
 331
 332         case SOUND_CHAN_CUSTOM:
 333             {
 334                 /* fixed point variables (matching MAS internal format)
 335                    integer part: upper 13 bits (inlcuding sign)
 336                    fractional part: lower 19 bits */
 337                 long fp_width, fp_straight, fp_cross;
 338
 339                 fp_width = (stereo_width << 19) / 100;
 340                 if (stereo_width <= 100)
 341                 {
 342                     fp_straight = - ((1<<19) + fp_width) / 2;
 343                     fp_cross = fp_straight + fp_width;
 344                 }
 345                 else
 346                 {
 347                     /* straight = - (1 + width) / (2 * width) */
 348                     fp_straight = - ((((1<<19) + fp_width) / (fp_width >> 9)) << 9);
 349                     fp_cross = (1<<19) + fp_straight;
 350                 }
 351                 val_ll = val_rr = fp_straight & 0xfffff;
 352                 val_lr = val_rl = fp_cross & 0xfffff;
 353             }
 354             break;
 355
 356         case SOUND_CHAN_MONO_LEFT:
 357             val_ll = 0x80000;
 358             val_lr = 0x80000;
 359             val_rl = 0;
 360             val_rr = 0;
 361             break;
 362
 363         case SOUND_CHAN_MONO_RIGHT:
 364             val_ll = 0;
 365             val_lr = 0;
 366             val_rl = 0x80000;
 367             val_rr = 0x80000;
 368             break;
 369
 370         case SOUND_CHAN_KARAOKE:
 371             val_ll = 0xc0000;
 372             val_lr = 0x40000;
 373             val_rl = 0x40000;
 374             val_rr = 0xc0000;
 375             break;
 376     }
 377
 378 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 379     mas_writemem(MAS_BANK_D0, MAS_D0_OUT_LL, &val_ll, 1); /* LL */
 380     mas_writemem(MAS_BANK_D0, MAS_D0_OUT_LR, &val_lr, 1); /* LR */
 381     mas_writemem(MAS_BANK_D0, MAS_D0_OUT_RL, &val_rl, 1); /* RL */
 382     mas_writemem(MAS_BANK_D0, MAS_D0_OUT_RR, &val_rr, 1); /* RR */
 383 #elif CONFIG_CODEC == MAS3507D
 384     mas_writemem(MAS_BANK_D1, 0x7f8, &val_ll, 1); /* LL */
 385     mas_writemem(MAS_BANK_D1, 0x7f9, &val_lr, 1); /* LR */
 386     mas_writemem(MAS_BANK_D1, 0x7fa, &val_rl, 1); /* RL */
 387     mas_writemem(MAS_BANK_D1, 0x7fb, &val_rr, 1); /* RR */
 388 #endif
 389 }
 390
 391 #endif /* CONFIG_CODEC != SWCODEC */
 392
 393 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 394 unsigned long mdb_shape_shadow = 0;
 395 unsigned long loudness_shadow = 0;
 396 #endif
 397
 398 void sound_set_volume(int value)
 399 {
 400     if(!audio_is_initialized)
 401         return;
 402 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 403     unsigned tmp = ((unsigned)(value + 115) & 0xff) << 8;
 404     mas_codec_writereg(0x10, tmp);
 405 #elif (CONFIG_CODEC == MAS3507D) || defined HAVE_UDA1380 \
 406    || defined HAVE_WM8975 || defined HAVE_WM8758 || defined HAVE_WM8731 \
 407    || defined(HAVE_WM8721) || defined(HAVE_TLV320) || defined(HAVE_WM8751) \
 408    || defined(HAVE_AS3514)
 409     current_volume = value * 10;     /* tenth of dB */
 410     set_prescaled_volume();
 411 #elif CONFIG_CPU == PNX0101
 412     int tmp = (60 - value * 4) & 0xff;
 413     CODECVOL = tmp | (tmp << 8);
 414 #endif
 415 }
 416
 417 void sound_set_balance(int value)
 418 {
 419     if(!audio_is_initialized)
 420         return;
 421 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 422     unsigned tmp = ((unsigned)(value * 127 / 100) & 0xff) << 8;
 423     mas_codec_writereg(0x11, tmp);
 424 #elif CONFIG_CODEC == MAS3507D || defined HAVE_UDA1380 \
 425    || defined HAVE_WM8975 || defined HAVE_WM8758 || defined HAVE_WM8731 \
 426    || defined(HAVE_WM8721) || defined(HAVE_TLV320) || defined(HAVE_WM8751) \
 427    || defined(HAVE_AS3514)
 428     current_balance = value * VOLUME_RANGE / 100; /* tenth of dB */
 429     set_prescaled_volume();
 430 #elif CONFIG_CPU == PNX0101
 431     /* TODO: implement for iFP */
 432     (void)value;
 433 #endif
 434 }
 435
 436 void sound_set_bass(int value)
 437 {
 438     if(!audio_is_initialized)
 439         return;
 440 #if defined(HAVE_SW_TONE_CONTROLS)
 441     current_bass = value * 10;
 442     dsp_callback(DSP_CALLBACK_SET_BASS, current_bass);
 443     set_prescaled_volume();
 444 #elif (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 445     unsigned tmp = ((unsigned)(value * 8) & 0xff) << 8;
 446     mas_codec_writereg(0x14, tmp);
 447 #elif CONFIG_CODEC == MAS3507D
 448     mas_writereg(MAS_REG_KBASS, bass_table[value+15]);
 449     current_bass = value * 10;
 450     set_prescaled_volume();
 451 #elif defined(HAVE_WM8751)
 452     current_bass = value;
 453     audiohw_set_bass(value);
 454     set_prescaled_volume();
 455 #elif defined HAVE_WM8975 || defined HAVE_WM8758 || defined(HAVE_UDA1380) \
 456     || defined HAVE_WM8731 || defined(HAVE_WM8721)
 457     current_bass = value * 10;
 458     audiohw_set_bass(value);
 459     set_prescaled_volume();
 460 #elif CONFIG_CPU == PNX0101
 461     /* TODO: implement for iFP */
 462     (void)value;
 463 #endif
 464 }
 465
 466 void sound_set_treble(int value)
 467 {
 468     if(!audio_is_initialized)
 469         return;
 470 #if defined(HAVE_SW_TONE_CONTROLS)
 471     current_treble = value * 10;
 472     dsp_callback(DSP_CALLBACK_SET_TREBLE, current_treble);
 473     set_prescaled_volume();
 474 #elif (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 475     unsigned tmp = ((unsigned)(value * 8) & 0xff) << 8;
 476     mas_codec_writereg(0x15, tmp);
 477 #elif CONFIG_CODEC == MAS3507D
 478     mas_writereg(MAS_REG_KTREBLE, treble_table[value+15]);
 479     current_treble = value * 10;
 480     set_prescaled_volume();
 481 #elif defined(HAVE_WM8751)
 482     audiohw_set_treble(value);
 483     current_treble = value;
 484     set_prescaled_volume();
 485 #elif defined(HAVE_WM8975) || defined(HAVE_WM8758) || defined(HAVE_UDA1380) \
 486    || defined(HAVE_WM8731) || defined(HAVE_WM8721)
 487     audiohw_set_treble(value);
 488     current_treble = value * 10;
 489     set_prescaled_volume();
 490 #elif CONFIG_CPU == PNX0101
 491     /* TODO: implement for iFP */
 492     (void)value;
 493 #endif
 494 }
 495
 496 void sound_set_channels(int value)
 497 {
 498 #if CONFIG_CODEC == SWCODEC
 499     dsp_callback(DSP_CALLBACK_SET_CHANNEL_CONFIG, value);
 500 #else
 501     if(!audio_is_initialized)
 502         return;
 503     channel_configuration = value;
 504     set_channel_config();
 505 #endif
 506 }
 507
 508 void sound_set_stereo_width(int value)
 509 {
 510 #if CONFIG_CODEC == SWCODEC
 511     dsp_callback(DSP_CALLBACK_SET_STEREO_WIDTH, value);
 512 #else
 513     if(!audio_is_initialized)
 514         return;
 515     stereo_width = value;
 516     if (channel_configuration == SOUND_CHAN_CUSTOM)
 517         set_channel_config();
 518 #endif
 519 }
 520
 521 #ifdef HAVE_WM8758
 522 void sound_set_bass_cutoff(int value)
 523 {
 524     if(!audio_is_initialized)
 525         return;
 526
 527     audiohw_set_bass_cutoff(value);
 528 }
 529
 530 void sound_set_treble_cutoff(int value)
 531 {
 532     if(!audio_is_initialized)
 533         return;
 534
 535     audiohw_set_treble_cutoff(value);
 536 }
 537 #endif
 538
 539 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 540 void sound_set_loudness(int value)
 541 {
 542     if(!audio_is_initialized)
 543         return;
 544     loudness_shadow = (loudness_shadow & 0x04) |
 545                        (MAX(MIN(value * 4, 0x44), 0) << 8);
 546     mas_codec_writereg(MAS_REG_KLOUDNESS, loudness_shadow);
 547 }
 548
 549 void sound_set_avc(int value)
 550 {
 551     if(!audio_is_initialized)
 552         return;
 553     int tmp;
 554     switch (value) {
 555         case 1: /* 20ms */
 556             tmp = (0x1 << 8) | (0x8 << 12);
 557             break;
 558         case 2: /* 2s */
 559             tmp = (0x2 << 8) | (0x8 << 12);
 560             break;
 561         case 3: /* 4s */
 562             tmp = (0x4 << 8) | (0x8 << 12);
 563             break;
 564         case 4: /* 8s */
 565             tmp = (0x8 << 8) | (0x8 << 12);
 566             break;
 567         case -1: /* turn off and then turn on again to decay quickly */
 568             tmp = mas_codec_readreg(MAS_REG_KAVC);
 569             mas_codec_writereg(MAS_REG_KAVC, 0);
 570             break;
 571         default: /* off */
 572             tmp = 0;
 573             break;
 574     }
 575     mas_codec_writereg(MAS_REG_KAVC, tmp);
 576 }
 577
 578 void sound_set_mdb_strength(int value)
 579 {
 580     if(!audio_is_initialized)
 581         return;
 582     mas_codec_writereg(MAS_REG_KMDB_STR, (value & 0x7f) << 8);
 583 }
 584
 585 void sound_set_mdb_harmonics(int value)
 586 {
 587     if(!audio_is_initialized)
 588         return;
 589     int tmp = value * 127 / 100;
 590     mas_codec_writereg(MAS_REG_KMDB_HAR, (tmp & 0x7f) << 8);
 591 }
 592
 593 void sound_set_mdb_center(int value)
 594 {
 595     if(!audio_is_initialized)
 596         return;
 597     mas_codec_writereg(MAS_REG_KMDB_FC, (value/10) << 8);
 598 }
 599
 600 void sound_set_mdb_shape(int value)
 601 {
 602     if(!audio_is_initialized)
 603         return;
 604     mdb_shape_shadow = (mdb_shape_shadow & 0x02) | ((value/10) << 8);
 605     mas_codec_writereg(MAS_REG_KMDB_SWITCH, mdb_shape_shadow);
 606 }
 607
 608 void sound_set_mdb_enable(int value)
 609 {
 610     if(!audio_is_initialized)
 611         return;
 612     mdb_shape_shadow = (mdb_shape_shadow & ~0x02) | (value?2:0);
 613     mas_codec_writereg(MAS_REG_KMDB_SWITCH, mdb_shape_shadow);
 614 }
 615
 616 void sound_set_superbass(int value)
 617 {
 618     if(!audio_is_initialized)
 619         return;
 620     loudness_shadow = (loudness_shadow & ~0x04) | (value?4:0);
 621     mas_codec_writereg(MAS_REG_KLOUDNESS, loudness_shadow);
 622 }
 623 #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */
 624
 625 #else /* SIMULATOR */
 626 int sim_volume;
 627 void sound_set_volume(int value)
 628 {
 629     /* 128 is SDL_MIX_MAXVOLUME */
 630     sim_volume = 128 * (value - VOLUME_MIN / 10) / (VOLUME_RANGE / 10);
 631 }
 632
 633 void sound_set_balance(int value)
 634 {
 635     (void)value;
 636 }
 637
 638 void sound_set_bass(int value)
 639 {
 640     (void)value;
 641 }
 642
 643 void sound_set_treble(int value)
 644 {
 645     (void)value;
 646 }
 647
 648 void sound_set_channels(int value)
 649 {
 650     (void)value;
 651 }
 652
 653 void sound_set_stereo_width(int value)
 654 {
 655     (void)value;
 656 }
 657
 658 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 659 void sound_set_loudness(int value)
 660 {
 661     (void)value;
 662 }
 663
 664 void sound_set_avc(int value)
 665 {
 666     (void)value;
 667 }
 668
 669 void sound_set_mdb_strength(int value)
 670 {
 671     (void)value;
 672 }
 673
 674 void sound_set_mdb_harmonics(int value)
 675 {
 676     (void)value;
 677 }
 678
 679 void sound_set_mdb_center(int value)
 680 {
 681     (void)value;
 682 }
 683
 684 void sound_set_mdb_shape(int value)
 685 {
 686     (void)value;
 687 }
 688
 689 void sound_set_mdb_enable(int value)
 690 {
 691     (void)value;
 692 }
 693
 694 void sound_set_superbass(int value)
 695 {
 696     (void)value;
 697 }
 698 #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */
 699
 700 #ifdef HAVE_WM8758
 701 void sound_set_bass_cutoff(int value)
 702 {
 703     (void) value;
 704 }
 705
 706 void sound_set_treble_cutoff(int value)
 707 {
 708     (void) value;
 709 }
 710 #endif /* HAVE_WM8758 */
 711
 712 #endif /* SIMULATOR */
 713
 714 void sound_set(int setting, int value)
 715 {
 716     sound_set_type* sound_set_val = sound_get_fn(setting);
 717     if (sound_set_val)
 718         sound_set_val(value);
 719 }
 720
 721 #if (!defined(HAVE_AS3514) && !defined (HAVE_WM8731)) || defined(SIMULATOR)
 722 int sound_val2phys(int setting, int value)
 723 {
 724 #if CONFIG_CODEC == MAS3587F
 725     int result = 0;
 726
 727     switch(setting)
 728     {
 729         case SOUND_LEFT_GAIN:
 730         case SOUND_RIGHT_GAIN:
 731             result = (value - 2) * 15;
 732             break;
 733
 734         case SOUND_MIC_GAIN:
 735             result = value * 15 + 210;
 736             break;
 737
 738        default:
 739             result = value;
 740             break;
 741     }
 742     return result;
 743 #elif defined(HAVE_UDA1380)
 744     int result = 0;
 745
 746     switch(setting)
 747     {
 748         case SOUND_LEFT_GAIN:
 749         case SOUND_RIGHT_GAIN:
 750         case SOUND_MIC_GAIN:
 751             result = value * 5;         /* (1/2) * 10 */
 752             break;
 753
 754         default:
 755             result = value;
 756             break;
 757     }
 758     return result;
 759 #elif defined(HAVE_TLV320) || defined(HAVE_WM8731)
 760     int result = 0;
 761
 762     switch(setting)
 763     {
 764         case SOUND_LEFT_GAIN:
 765         case SOUND_RIGHT_GAIN:
 766             result = (value - 23) * 15;    /* (x - 23)/1.5 *10 */
 767             break;
 768
 769         case SOUND_MIC_GAIN:
 770             result = value * 200;          /* 0 or 20 dB */
 771             break;
 772
 773        default:
 774             result = value;
 775             break;
 776     }
 777     return result;
 778 #elif defined(HAVE_AS3514)
 779     /* This is here for the sim only and the audio driver has its own */
 780     int result;
 781
 782     switch(setting)
 783     {
 784     case SOUND_LEFT_GAIN:
 785     case SOUND_RIGHT_GAIN:
 786     case SOUND_MIC_GAIN:
 787         result = (value - 23) * 15;
 788         break;
 789
 790     default:
 791         result = value;
 792         break;
 793     }
 794
 795     return result;
 796 #else
 797     (void)setting;
 798     return value;
 799 #endif
 800 }
 801 #endif /* !defined(HAVE_AS3514) || defined(SIMULATOR) */
 802
 803 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 804 #ifndef SIMULATOR
 805 /* This function works by telling the decoder that we have another
 806    crystal frequency than we actually have. It will adjust its internal
 807    parameters and the result is that the audio is played at another pitch.
 808
 809    The pitch value is in tenths of percent.
 810 */
 811 static int last_pitch = 1000;
 812
 813 void sound_set_pitch(int pitch)
 814 {
 815     unsigned long val;
 816
 817     if (pitch != last_pitch)
 818     {
 819         /* Calculate the new (bogus) frequency */
 820         val = 18432 * 1000 / pitch;
 821
 822         mas_writemem(MAS_BANK_D0, MAS_D0_OFREQ_CONTROL, &val, 1);
 823
 824         /* We must tell the MAS that the frequency has changed.
 825          * This will unfortunately cause a short silence. */
 826         mas_writemem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &shadow_io_control_main, 1);
 827
 828         last_pitch = pitch;
 829     }
 830 }
 831
 832 int sound_get_pitch(void)
 833 {
 834     return last_pitch;
 835 }
 836 #else /* SIMULATOR */
 837 void sound_set_pitch(int pitch)
 838 {
 839     (void)pitch;
 840 }
 841
 842 int sound_get_pitch(void)
 843 {
 844     return 1000;
 845 }
 846 #endif /* SIMULATOR */
 847 #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */