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) || defined(HAVE_WM8985)
 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) || defined(HAVE_WM8985))
 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) || defined(HAVE_WM8985)
 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     (void)value;
 416 }
 417
 418 void sound_set_balance(int value)
 419 {
 420     if(!audio_is_initialized)
 421         return;
 422 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 423     unsigned tmp = ((unsigned)(value * 127 / 100) & 0xff) << 8;
 424     mas_codec_writereg(0x11, tmp);
 425 #elif CONFIG_CODEC == MAS3507D || defined HAVE_UDA1380 \
 426    || defined HAVE_WM8975 || defined HAVE_WM8758 || defined HAVE_WM8731 \
 427    || defined(HAVE_WM8721) || defined(HAVE_TLV320) || defined(HAVE_WM8751) \
 428    || defined(HAVE_AS3514) || defined(HAVE_WM8985)
 429     current_balance = value * VOLUME_RANGE / 100; /* tenth of dB */
 430     set_prescaled_volume();
 431 #elif CONFIG_CPU == PNX0101
 432     /* TODO: implement for iFP */
 433 #endif
 434     (void)value;
 435 }
 436
 437 void sound_set_bass(int value)
 438 {
 439     if(!audio_is_initialized)
 440         return;
 441 #if defined(HAVE_SW_TONE_CONTROLS)
 442     current_bass = value * 10;
 443     dsp_callback(DSP_CALLBACK_SET_BASS, current_bass);
 444     set_prescaled_volume();
 445 #elif (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 446     unsigned tmp = ((unsigned)(value * 8) & 0xff) << 8;
 447     mas_codec_writereg(0x14, tmp);
 448 #elif CONFIG_CODEC == MAS3507D
 449     mas_writereg(MAS_REG_KBASS, bass_table[value+15]);
 450     current_bass = value * 10;
 451     set_prescaled_volume();
 452 #elif defined(HAVE_WM8751)
 453     current_bass = value;
 454     audiohw_set_bass(value);
 455     set_prescaled_volume();
 456 #elif defined HAVE_WM8975 || defined HAVE_WM8758 || defined(HAVE_UDA1380) \
 457     || defined HAVE_WM8731 || defined(HAVE_WM8721) || defined(HAVE_WM8985)
 458     current_bass = value * 10;
 459     audiohw_set_bass(value);
 460     set_prescaled_volume();
 461 #elif CONFIG_CPU == PNX0101
 462     /* TODO: implement for iFP */
 463 #endif
 464     (void)value;
 465 }
 466
 467 void sound_set_treble(int value)
 468 {
 469     if(!audio_is_initialized)
 470         return;
 471 #if defined(HAVE_SW_TONE_CONTROLS)
 472     current_treble = value * 10;
 473     dsp_callback(DSP_CALLBACK_SET_TREBLE, current_treble);
 474     set_prescaled_volume();
 475 #elif (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 476     unsigned tmp = ((unsigned)(value * 8) & 0xff) << 8;
 477     mas_codec_writereg(0x15, tmp);
 478 #elif CONFIG_CODEC == MAS3507D
 479     mas_writereg(MAS_REG_KTREBLE, treble_table[value+15]);
 480     current_treble = value * 10;
 481     set_prescaled_volume();
 482 #elif defined(HAVE_WM8751)
 483     audiohw_set_treble(value);
 484     current_treble = value;
 485     set_prescaled_volume();
 486 #elif defined(HAVE_WM8975) || defined(HAVE_WM8758) || defined(HAVE_UDA1380) \
 487    || defined(HAVE_WM8731) || defined(HAVE_WM8721) || defined(HAVE_WM8985)
 488     audiohw_set_treble(value);
 489     current_treble = value * 10;
 490     set_prescaled_volume();
 491 #elif CONFIG_CPU == PNX0101
 492     /* TODO: implement for iFP */
 493 #endif
 494     (void)value;
 495 }
 496
 497 void sound_set_channels(int value)
 498 {
 499 #if CONFIG_CODEC == SWCODEC
 500     dsp_callback(DSP_CALLBACK_SET_CHANNEL_CONFIG, value);
 501 #else
 502     if(!audio_is_initialized)
 503         return;
 504     channel_configuration = value;
 505     set_channel_config();
 506 #endif
 507 }
 508
 509 void sound_set_stereo_width(int value)
 510 {
 511 #if CONFIG_CODEC == SWCODEC
 512     dsp_callback(DSP_CALLBACK_SET_STEREO_WIDTH, value);
 513 #else
 514     if(!audio_is_initialized)
 515         return;
 516     stereo_width = value;
 517     if (channel_configuration == SOUND_CHAN_CUSTOM)
 518         set_channel_config();
 519 #endif
 520 }
 521
 522 #if defined(HAVE_WM8758) || defined(HAVE_WM8985)
 523 void sound_set_bass_cutoff(int value)
 524 {
 525     if(!audio_is_initialized)
 526         return;
 527
 528     audiohw_set_bass_cutoff(value);
 529 }
 530
 531 void sound_set_treble_cutoff(int value)
 532 {
 533     if(!audio_is_initialized)
 534         return;
 535
 536     audiohw_set_treble_cutoff(value);
 537 }
 538 #endif
 539
 540 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 541 void sound_set_loudness(int value)
 542 {
 543     if(!audio_is_initialized)
 544         return;
 545     loudness_shadow = (loudness_shadow & 0x04) |
 546                        (MAX(MIN(value * 4, 0x44), 0) << 8);
 547     mas_codec_writereg(MAS_REG_KLOUDNESS, loudness_shadow);
 548 }
 549
 550 void sound_set_avc(int value)
 551 {
 552     if(!audio_is_initialized)
 553         return;
 554     int tmp;
 555     switch (value) {
 556         case 1: /* 20ms */
 557             tmp = (0x1 << 8) | (0x8 << 12);
 558             break;
 559         case 2: /* 2s */
 560             tmp = (0x2 << 8) | (0x8 << 12);
 561             break;
 562         case 3: /* 4s */
 563             tmp = (0x4 << 8) | (0x8 << 12);
 564             break;
 565         case 4: /* 8s */
 566             tmp = (0x8 << 8) | (0x8 << 12);
 567             break;
 568         case -1: /* turn off and then turn on again to decay quickly */
 569             tmp = mas_codec_readreg(MAS_REG_KAVC);
 570             mas_codec_writereg(MAS_REG_KAVC, 0);
 571             break;
 572         default: /* off */
 573             tmp = 0;
 574             break;
 575     }
 576     mas_codec_writereg(MAS_REG_KAVC, tmp);
 577 }
 578
 579 void sound_set_mdb_strength(int value)
 580 {
 581     if(!audio_is_initialized)
 582         return;
 583     mas_codec_writereg(MAS_REG_KMDB_STR, (value & 0x7f) << 8);
 584 }
 585
 586 void sound_set_mdb_harmonics(int value)
 587 {
 588     if(!audio_is_initialized)
 589         return;
 590     int tmp = value * 127 / 100;
 591     mas_codec_writereg(MAS_REG_KMDB_HAR, (tmp & 0x7f) << 8);
 592 }
 593
 594 void sound_set_mdb_center(int value)
 595 {
 596     if(!audio_is_initialized)
 597         return;
 598     mas_codec_writereg(MAS_REG_KMDB_FC, (value/10) << 8);
 599 }
 600
 601 void sound_set_mdb_shape(int value)
 602 {
 603     if(!audio_is_initialized)
 604         return;
 605     mdb_shape_shadow = (mdb_shape_shadow & 0x02) | ((value/10) << 8);
 606     mas_codec_writereg(MAS_REG_KMDB_SWITCH, mdb_shape_shadow);
 607 }
 608
 609 void sound_set_mdb_enable(int value)
 610 {
 611     if(!audio_is_initialized)
 612         return;
 613     mdb_shape_shadow = (mdb_shape_shadow & ~0x02) | (value?2:0);
 614     mas_codec_writereg(MAS_REG_KMDB_SWITCH, mdb_shape_shadow);
 615 }
 616
 617 void sound_set_superbass(int value)
 618 {
 619     if(!audio_is_initialized)
 620         return;
 621     loudness_shadow = (loudness_shadow & ~0x04) | (value?4:0);
 622     mas_codec_writereg(MAS_REG_KLOUDNESS, loudness_shadow);
 623 }
 624 #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */
 625
 626 #else /* SIMULATOR */
 627 int sim_volume;
 628 void sound_set_volume(int value)
 629 {
 630     /* 128 is SDL_MIX_MAXVOLUME */
 631     sim_volume = 128 * (value - VOLUME_MIN / 10) / (VOLUME_RANGE / 10);
 632 }
 633
 634 void sound_set_balance(int value)
 635 {
 636     (void)value;
 637 }
 638
 639 void sound_set_bass(int value)
 640 {
 641     (void)value;
 642 }
 643
 644 void sound_set_treble(int value)
 645 {
 646     (void)value;
 647 }
 648
 649 void sound_set_channels(int value)
 650 {
 651     (void)value;
 652 }
 653
 654 void sound_set_stereo_width(int value)
 655 {
 656     (void)value;
 657 }
 658
 659 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 660 void sound_set_loudness(int value)
 661 {
 662     (void)value;
 663 }
 664
 665 void sound_set_avc(int value)
 666 {
 667     (void)value;
 668 }
 669
 670 void sound_set_mdb_strength(int value)
 671 {
 672     (void)value;
 673 }
 674
 675 void sound_set_mdb_harmonics(int value)
 676 {
 677     (void)value;
 678 }
 679
 680 void sound_set_mdb_center(int value)
 681 {
 682     (void)value;
 683 }
 684
 685 void sound_set_mdb_shape(int value)
 686 {
 687     (void)value;
 688 }
 689
 690 void sound_set_mdb_enable(int value)
 691 {
 692     (void)value;
 693 }
 694
 695 void sound_set_superbass(int value)
 696 {
 697     (void)value;
 698 }
 699 #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */
 700
 701 #if defined(HAVE_WM8758) || defined(HAVE_WM8985)
 702 void sound_set_bass_cutoff(int value)
 703 {
 704     (void) value;
 705 }
 706
 707 void sound_set_treble_cutoff(int value)
 708 {
 709     (void) value;
 710 }
 711 #endif /* HAVE_WM8758 */
 712
 713 #endif /* SIMULATOR */
 714
 715 void sound_set(int setting, int value)
 716 {
 717     sound_set_type* sound_set_val = sound_get_fn(setting);
 718     if (sound_set_val)
 719         sound_set_val(value);
 720 }
 721
 722 #if (!defined(HAVE_AS3514) && !defined (HAVE_WM8731)) || defined(SIMULATOR)
 723 int sound_val2phys(int setting, int value)
 724 {
 725 #if CONFIG_CODEC == MAS3587F
 726     int result = 0;
 727
 728     switch(setting)
 729     {
 730         case SOUND_LEFT_GAIN:
 731         case SOUND_RIGHT_GAIN:
 732             result = (value - 2) * 15;
 733             break;
 734
 735         case SOUND_MIC_GAIN:
 736             result = value * 15 + 210;
 737             break;
 738
 739        default:
 740             result = value;
 741             break;
 742     }
 743     return result;
 744 #elif defined(HAVE_UDA1380)
 745     int result = 0;
 746
 747     switch(setting)
 748     {
 749         case SOUND_LEFT_GAIN:
 750         case SOUND_RIGHT_GAIN:
 751         case SOUND_MIC_GAIN:
 752             result = value * 5;         /* (1/2) * 10 */
 753             break;
 754
 755         default:
 756             result = value;
 757             break;
 758     }
 759     return result;
 760 #elif defined(HAVE_TLV320) || defined(HAVE_WM8731)
 761     int result = 0;
 762
 763     switch(setting)
 764     {
 765         case SOUND_LEFT_GAIN:
 766         case SOUND_RIGHT_GAIN:
 767             result = (value - 23) * 15;    /* (x - 23)/1.5 *10 */
 768             break;
 769
 770         case SOUND_MIC_GAIN:
 771             result = value * 200;          /* 0 or 20 dB */
 772             break;
 773
 774        default:
 775             result = value;
 776             break;
 777     }
 778     return result;
 779 #elif defined(HAVE_AS3514)
 780     /* This is here for the sim only and the audio driver has its own */
 781     int result;
 782
 783     switch(setting)
 784     {
 785     case SOUND_LEFT_GAIN:
 786     case SOUND_RIGHT_GAIN:
 787     case SOUND_MIC_GAIN:
 788         result = (value - 23) * 15;
 789         break;
 790
 791     default:
 792         result = value;
 793         break;
 794     }
 795
 796     return result;
 797 #else
 798     (void)setting;
 799     return value;
 800 #endif
 801 }
 802 #endif /* !defined(HAVE_AS3514) || defined(SIMULATOR) */
 803
 804 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 805 #ifndef SIMULATOR
 806 /* This function works by telling the decoder that we have another
 807    crystal frequency than we actually have. It will adjust its internal
 808    parameters and the result is that the audio is played at another pitch.
 809
 810    The pitch value is in tenths of percent.
 811 */
 812 static int last_pitch = 1000;
 813
 814 void sound_set_pitch(int pitch)
 815 {
 816     unsigned long val;
 817
 818     if (pitch != last_pitch)
 819     {
 820         /* Calculate the new (bogus) frequency */
 821         val = 18432 * 1000 / pitch;
 822
 823         mas_writemem(MAS_BANK_D0, MAS_D0_OFREQ_CONTROL, &val, 1);
 824
 825         /* We must tell the MAS that the frequency has changed.
 826          * This will unfortunately cause a short silence. */
 827         mas_writemem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &shadow_io_control_main, 1);
 828
 829         last_pitch = pitch;
 830     }
 831 }
 832
 833 int sound_get_pitch(void)
 834 {
 835     return last_pitch;
 836 }
 837 #else /* SIMULATOR */
 838 void sound_set_pitch(int pitch)
 839 {
 840     (void)pitch;
 841 }
 842
 843 int sound_get_pitch(void)
 844 {
 845     return 1000;
 846 }
 847 #endif /* SIMULATOR */
 848 #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */