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 #include "i2c.h"
  29
  30 /* TODO
  31  * find a nice way to handle 1.5db steps -> see wm8751 ifdef in sound_set_bass/treble
  32 */
  33
  34 extern bool audio_is_initialized;
  35
  36 const char *sound_unit(int setting)
  37 {
  38     return audiohw_settings[setting].unit;
  39 }
  40
  41 int sound_numdecimals(int setting)
  42 {
  43     return audiohw_settings[setting].numdecimals;
  44 }
  45
  46 int sound_steps(int setting)
  47 {
  48     return audiohw_settings[setting].steps;
  49 }
  50
  51 int sound_min(int setting)
  52 {
  53     return audiohw_settings[setting].minval;
  54 }
  55
  56 int sound_max(int setting)
  57 {
  58     return audiohw_settings[setting].maxval;
  59 }
  60
  61 int sound_default(int setting)
  62 {
  63     return audiohw_settings[setting].defaultval;
  64 }
  65
  66 static sound_set_type * const sound_set_fns[] =
  67 {
  68     [0 ... SOUND_LAST_SETTING-1] = NULL,
  69     [SOUND_VOLUME]        = sound_set_volume,
  70 #if defined(AUDIOHW_HAVE_BASS)
  71     [SOUND_BASS]          = sound_set_bass,
  72 #endif
  73 #if defined(AUDIOHW_HAVE_TREBLE)
  74     [SOUND_TREBLE]        = sound_set_treble,
  75 #endif
  76     [SOUND_BALANCE]       = sound_set_balance,
  77     [SOUND_CHANNELS]      = sound_set_channels,
  78     [SOUND_STEREO_WIDTH]  = sound_set_stereo_width,
  79 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
  80     [SOUND_LOUDNESS]      = sound_set_loudness,
  81     [SOUND_AVC]           = sound_set_avc,
  82     [SOUND_MDB_STRENGTH]  = sound_set_mdb_strength,
  83     [SOUND_MDB_HARMONICS] = sound_set_mdb_harmonics,
  84     [SOUND_MDB_CENTER]    = sound_set_mdb_center,
  85     [SOUND_MDB_SHAPE]     = sound_set_mdb_shape,
  86     [SOUND_MDB_ENABLE]    = sound_set_mdb_enable,
  87     [SOUND_SUPERBASS]     = sound_set_superbass,
  88 #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */
  89 #if defined(AUDIOHW_HAVE_BASS_CUTOFF)
  90     [SOUND_BASS_CUTOFF]   = sound_set_bass_cutoff,
  91 #endif
  92 #if defined(AUDIOHW_HAVE_TREBLE_CUTOFF)
  93     [SOUND_TREBLE_CUTOFF] = sound_set_treble_cutoff,
  94 #endif
  95 #if defined(AUDIOHW_HAVE_DEPTH_3D)
  96     [SOUND_DEPTH_3D]      = sound_set_depth_3d,
  97 #endif
  98 /* Hardware EQ tone controls */
  99 #if defined(AUDIOHW_HAVE_EQ)
 100     [SOUND_EQ_BAND1_GAIN] = sound_set_hw_eq_band1_gain,
 101 #if defined(AUDIOHW_HAVE_EQ_BAND1_FREQUENCY)
 102     [SOUND_EQ_BAND1_FREQUENCY] = sound_set_hw_eq_band1_frequency,
 103 #endif
 104 #if defined(AUDIOHW_HAVE_EQ_BAND2)
 105     [SOUND_EQ_BAND2_GAIN] = sound_set_hw_eq_band2_gain,
 106 #if defined(AUDIOHW_HAVE_EQ_BAND2_FREQUENCY)
 107     [SOUND_EQ_BAND2_FREQUENCY] = sound_set_hw_eq_band2_frequency,
 108 #endif
 109 #if defined(AUDIOHW_HAVE_EQ_BAND2_WIDTH)
 110     [SOUND_EQ_BAND2_WIDTH] = sound_set_hw_eq_band2_width,
 111 #endif
 112 #endif /* AUDIOHW_HAVE_EQ_BAND2 */
 113 #if defined(AUDIOHW_HAVE_EQ_BAND3)
 114     [SOUND_EQ_BAND3_GAIN] = sound_set_hw_eq_band3_gain,
 115 #if defined(AUDIOHW_HAVE_EQ_BAND3_FREQUENCY)
 116     [SOUND_EQ_BAND3_FREQUENCY] = sound_set_hw_eq_band3_frequency,
 117 #endif
 118 #if defined(AUDIOHW_HAVE_EQ_BAND3_WIDTH)
 119     [SOUND_EQ_BAND3_WIDTH] = sound_set_hw_eq_band3_width,
 120 #endif
 121 #endif /* AUDIOHW_HAVE_EQ_BAND3 */
 122 #if defined(AUDIOHW_HAVE_EQ_BAND4)
 123     [SOUND_EQ_BAND4_GAIN] = sound_set_hw_eq_band4_gain,
 124 #if defined(AUDIOHW_HAVE_EQ_BAND4_FREQUENCY)
 125     [SOUND_EQ_BAND4_FREQUENCY] = sound_set_hw_eq_band4_frequency,
 126 #endif
 127 #if defined(AUDIOHW_HAVE_EQ_BAND4_WIDTH)
 128     [SOUND_EQ_BAND4_WIDTH] = sound_set_hw_eq_band4_width,
 129 #endif
 130 #endif /* AUDIOHW_HAVE_EQ_BAND4 */
 131 #if defined(AUDIOHW_HAVE_EQ_BAND5)
 132     [SOUND_EQ_BAND5_GAIN] = sound_set_hw_eq_band5_gain,
 133 #if defined(AUDIOHW_HAVE_EQ_BAND5_FREQUENCY)
 134     [SOUND_EQ_BAND5_FREQUENCY] = sound_set_hw_eq_band5_frequency,
 135 #endif
 136 #endif /* AUDIOHW_HAVE_EQ_BAND5 */
 137 #endif /* AUDIOHW_HAVE_EQ */
 138 };
 139
 140 sound_set_type* sound_get_fn(int setting)
 141 {
 142     return ((unsigned)setting >= ARRAYLEN(sound_set_fns)?
 143                 NULL : sound_set_fns[setting]);
 144 }
 145
 146 #if CONFIG_CODEC == SWCODEC
 147 static int (*dsp_callback)(int, intptr_t) = NULL;
 148
 149 void sound_set_dsp_callback(int (*func)(int, intptr_t))
 150 {
 151     dsp_callback = func;
 152 }
 153 #endif
 154
 155 #if !defined(AUDIOHW_HAVE_CLIPPING)
 156 /*
 157  * The prescaler compensates for any kind of boosts, to prevent clipping.
 158  *
 159  * It's basically just a measure to make sure that audio does not clip during
 160  * tone controls processing, like if i want to boost bass 12 dB, i can decrease
 161  * the audio amplitude by -12 dB before processing, then increase master gain
 162  * by 12 dB after processing.
 163  */
 164
 165 /* all values in tenth of dB          MAS3507D    UDA1380  */
 166 static int current_volume = 0;    /* -780..+180  -840..   0 */
 167 static int current_balance = 0;   /* -960..+960  -840..+840 */
 168 #ifdef AUDIOHW_HAVE_TREBLE
 169 static int current_treble = 0;    /* -150..+150     0.. +60 */
 170 #endif
 171 #ifdef AUDIOHW_HAVE_BASS
 172 static int current_bass = 0;      /* -150..+150     0..+240 */
 173 #endif
 174 #ifdef AUDIOHW_HAVE_EQ
 175 static int current_eq_band_gain[AUDIOHW_EQ_BAND_NUM];
 176 #endif
 177
 178 static void set_prescaled_volume(void)
 179 {
 180     int prescale = 0;
 181     int l, r;
 182
 183 /* The codecs listed use HW tone controls but don't have suitable prescaler
 184  * functionality, so we let the prescaler stay at 0 for these, unless
 185  * SW tone controls are in use. This is to avoid needing the SW DSP just for
 186  * the prescaling.
 187  */
 188 #if defined(HAVE_SW_TONE_CONTROLS) || !(defined(HAVE_WM8975) \
 189     || defined(HAVE_WM8711) || defined(HAVE_WM8721) || defined(HAVE_WM8731) \
 190     || defined(HAVE_WM8758) || defined(HAVE_WM8985) || defined(HAVE_UDA1341))
 191
 192 #if defined(AUDIOHW_HAVE_BASS) && defined(AUDIOHW_HAVE_TREBLE)
 193     prescale = MAX(current_bass, current_treble);
 194 #endif
 195 #if defined(AUDIOHW_HAVE_EQ)
 196     int i;
 197     for (i = 0; i < AUDIOHW_EQ_BAND_NUM; i++)
 198         prescale = MAX(current_eq_band_gain[i], prescale);
 199 #endif
 200
 201     if (prescale < 0)
 202         prescale = 0;  /* no need to prescale if we don't boost
 203                           bass, treble or eq band */
 204
 205     /* Gain up the analog volume to compensate the prescale gain reduction,
 206      * but if this would push the volume over the top, reduce prescaling
 207      * instead (might cause clipping). */
 208     if (current_volume + prescale > VOLUME_MAX)
 209         prescale = VOLUME_MAX - current_volume;
 210 #endif
 211
 212 #if defined(AUDIOHW_HAVE_PRESCALER)
 213     audiohw_set_prescaler(prescale);
 214 #else
 215     dsp_callback(DSP_CALLBACK_SET_PRESCALE, prescale);
 216 #endif
 217
 218     if (current_volume == VOLUME_MIN)
 219         prescale = 0;  /* Make sure the chip gets muted at VOLUME_MIN */
 220
 221     l = r = current_volume + prescale;
 222
 223     /* Balance the channels scaled by the current volume and min volume. */
 224     /* Subtract a dB from VOLUME_MIN to get it to a mute level */
 225     if (current_balance > 0)
 226     {
 227         l -= ((l - (VOLUME_MIN - ONE_DB)) * current_balance) / VOLUME_RANGE;
 228     }
 229     else if (current_balance < 0)
 230     {
 231         r += ((r - (VOLUME_MIN - ONE_DB)) * current_balance) / VOLUME_RANGE;
 232     }
 233
 234 #ifdef HAVE_SW_VOLUME_CONTROL
 235     dsp_callback(DSP_CALLBACK_SET_SW_VOLUME, 0);
 236 #endif
 237
 238 #ifndef HAVE_SDL_AUDIO
 239 #if CONFIG_CODEC == MAS3507D
 240     dac_volume(tenthdb2reg(l), tenthdb2reg(r), false);
 241 #elif defined(HAVE_UDA1380) || defined(HAVE_WM8975) || defined(HAVE_WM8758) \
 242    || defined(HAVE_WM8711) || defined(HAVE_WM8721) || defined(HAVE_WM8731) \
 243    || defined(HAVE_WM8750) || defined(HAVE_WM8751) || defined(HAVE_AS3514) \
 244    || defined(HAVE_TSC2100) || defined(HAVE_AK4537) || defined(HAVE_UDA1341) \
 245    || defined(HAVE_CS42L55)
 246     audiohw_set_master_vol(tenthdb2master(l), tenthdb2master(r));
 247 #if defined(HAVE_WM8975) || defined(HAVE_WM8758) \
 248     || (defined(HAVE_WM8751) && defined(TOSHIBA_GIGABEAT_F)) \
 249     || defined(HAVE_WM8985) || defined(HAVE_CS42L55)
 250     audiohw_set_lineout_vol(tenthdb2master(0), tenthdb2master(0));
 251 #endif
 252
 253 #elif defined(HAVE_TLV320) || defined(HAVE_WM8978) || defined(HAVE_WM8985)
 254     audiohw_set_headphone_vol(tenthdb2master(l), tenthdb2master(r));
 255 #elif defined(HAVE_JZ4740_CODEC) || defined(HAVE_SDL_AUDIO) || defined(ANDROID)
 256     audiohw_set_volume(current_volume);
 257 #endif
 258 #else /* HAVE_SDL_AUDIO */
 259     audiohw_set_volume(current_volume);
 260 #endif /* !HAVE_SDL_AUDIO */
 261 }
 262 #endif /* (CONFIG_CODEC == MAS3507D) || defined HAVE_UDA1380 */
 263
 264 void sound_set_volume(int value)
 265 {
 266     if(!audio_is_initialized)
 267         return;
 268
 269 #if defined(AUDIOHW_HAVE_CLIPPING)
 270     audiohw_set_volume(value);
 271 #elif CONFIG_CPU == PNX0101
 272     int tmp = (60 - value * 4) & 0xff;
 273     CODECVOL = tmp | (tmp << 8);
 274 #else
 275     current_volume = value * 10;     /* tenth of dB */
 276     set_prescaled_volume();
 277 #endif
 278 }
 279
 280 void sound_set_balance(int value)
 281 {
 282     if(!audio_is_initialized)
 283         return;
 284
 285 #ifdef AUDIOHW_HAVE_BALANCE
 286     audiohw_set_balance(value);
 287 #else
 288     current_balance = value * VOLUME_RANGE / 100; /* tenth of dB */
 289     set_prescaled_volume();
 290 #endif
 291 }
 292
 293 #ifdef AUDIOHW_HAVE_BASS
 294 void sound_set_bass(int value)
 295 {
 296     if(!audio_is_initialized)
 297         return;
 298
 299 #if !defined(AUDIOHW_HAVE_CLIPPING)
 300 #if defined(HAVE_WM8750) || defined(HAVE_WM8751) || defined(HAVE_CS42L55)
 301     current_bass = value;
 302 #else
 303     current_bass =  value * 10;
 304 #endif
 305 #endif
 306
 307 #if defined(HAVE_SW_TONE_CONTROLS)
 308     dsp_callback(DSP_CALLBACK_SET_BASS, current_bass);
 309 #else
 310     audiohw_set_bass(value);
 311 #endif
 312
 313 #if !defined(AUDIOHW_HAVE_CLIPPING)
 314     set_prescaled_volume();
 315 #endif
 316 }
 317 #endif /* AUDIOHW_HAVE_BASS */
 318
 319 #ifdef AUDIOHW_HAVE_TREBLE
 320 void sound_set_treble(int value)
 321 {
 322     if(!audio_is_initialized)
 323         return;
 324
 325 #if !defined(AUDIOHW_HAVE_CLIPPING)
 326 #if defined(HAVE_WM8750) || defined(HAVE_WM8751) || defined(HAVE_CS42L55)
 327     current_treble = value;
 328 #else
 329     current_treble = value * 10;
 330 #endif
 331 #endif
 332
 333 #if defined(HAVE_SW_TONE_CONTROLS)
 334     dsp_callback(DSP_CALLBACK_SET_TREBLE, current_treble);
 335 #else
 336     audiohw_set_treble(value);
 337 #endif
 338
 339 #if !defined(AUDIOHW_HAVE_CLIPPING)
 340     set_prescaled_volume();
 341 #endif
 342 }
 343 #endif /* AUDIOHW_HAVE_TREBLE */
 344
 345 #if defined(AUDIOHW_HAVE_BASS_CUTOFF)
 346 void sound_set_bass_cutoff(int value)
 347 {
 348     if(!audio_is_initialized)
 349         return;
 350
 351     audiohw_set_bass_cutoff(value);
 352 }
 353 #endif
 354
 355 #if defined(AUDIOHW_HAVE_TREBLE_CUTOFF)
 356 void sound_set_treble_cutoff(int value)
 357 {
 358     if(!audio_is_initialized)
 359         return;
 360
 361     audiohw_set_treble_cutoff(value);
 362 }
 363 #endif
 364
 365 void sound_set_channels(int value)
 366 {
 367     if(!audio_is_initialized)
 368         return;
 369
 370 #if CONFIG_CODEC == SWCODEC
 371     dsp_callback(DSP_CALLBACK_SET_CHANNEL_CONFIG, value);
 372 #else
 373     audiohw_set_channel(value);
 374 #endif
 375 }
 376
 377 void sound_set_stereo_width(int value)
 378 {
 379     if(!audio_is_initialized)
 380         return;
 381
 382 #if CONFIG_CODEC == SWCODEC
 383     dsp_callback(DSP_CALLBACK_SET_STEREO_WIDTH, value);
 384 #else
 385     audiohw_set_stereo_width(value);
 386 #endif
 387 }
 388
 389 #if defined(AUDIOHW_HAVE_DEPTH_3D)
 390 void sound_set_depth_3d(int value)
 391 {
 392     if(!audio_is_initialized)
 393         return;
 394
 395     audiohw_set_depth_3d(value);
 396 }
 397 #endif
 398
 399 #if defined(AUDIOHW_HAVE_EQ)
 400 int sound_enum_hw_eq_band_setting(unsigned int band,
 401                                   unsigned int band_setting)
 402 {
 403     static const int8_t
 404     sound_hw_eq_band_setting[AUDIOHW_EQ_SETTING_NUM][AUDIOHW_EQ_BAND_NUM] =
 405     {
 406         [AUDIOHW_EQ_GAIN] =
 407         {
 408             [0 ... AUDIOHW_EQ_BAND_NUM-1] = -1,
 409             [AUDIOHW_EQ_BAND1] = SOUND_EQ_BAND1_GAIN,
 410         #ifdef AUDIOHW_HAVE_EQ_BAND2
 411             [AUDIOHW_EQ_BAND2] = SOUND_EQ_BAND2_GAIN,
 412         #endif
 413         #ifdef AUDIOHW_HAVE_EQ_BAND3
 414             [AUDIOHW_EQ_BAND3] = SOUND_EQ_BAND3_GAIN,
 415         #endif
 416         #ifdef AUDIOHW_HAVE_EQ_BAND4
 417             [AUDIOHW_EQ_BAND4] = SOUND_EQ_BAND4_GAIN,
 418         #endif
 419         #ifdef AUDIOHW_HAVE_EQ_BAND5
 420             [AUDIOHW_EQ_BAND5] = SOUND_EQ_BAND5_GAIN,
 421         #endif
 422         },
 423 #ifdef AUDIOHW_HAVE_EQ_FREQUENCY
 424         [AUDIOHW_EQ_FREQUENCY] =
 425         {
 426             [0 ... AUDIOHW_EQ_BAND_NUM-1] = -1,
 427         #ifdef AUDIOHW_HAVE_EQ_BAND1_FREQUENCY
 428             [AUDIOHW_EQ_BAND1] = SOUND_EQ_BAND1_FREQUENCY,
 429         #endif
 430         #ifdef AUDIOHW_HAVE_EQ_BAND2_FREQUENCY
 431             [AUDIOHW_EQ_BAND2] = SOUND_EQ_BAND2_FREQUENCY,
 432         #endif
 433         #ifdef AUDIOHW_HAVE_EQ_BAND3_FREQUENCY
 434             [AUDIOHW_EQ_BAND3] = SOUND_EQ_BAND3_FREQUENCY,
 435         #endif
 436         #ifdef AUDIOHW_HAVE_EQ_BAND4_FREQUENCY
 437             [AUDIOHW_EQ_BAND4] = SOUND_EQ_BAND4_FREQUENCY,
 438         #endif
 439         #ifdef AUDIOHW_HAVE_EQ_BAND5_FREQUENCY
 440             [AUDIOHW_EQ_BAND5] = SOUND_EQ_BAND5_FREQUENCY,
 441         #endif
 442         },
 443 #endif /* AUDIOHW_HAVE_EQ_FREQUENCY */
 444 #ifdef AUDIOHW_HAVE_EQ_WIDTH
 445         [AUDIOHW_EQ_WIDTH] =
 446         {
 447             [0 ... AUDIOHW_EQ_BAND_NUM-1] = -1,
 448         #ifdef AUDIOHW_HAVE_EQ_BAND2_WIDTH
 449             [AUDIOHW_EQ_BAND2] = SOUND_EQ_BAND2_WIDTH,
 450         #endif
 451         #ifdef AUDIOHW_HAVE_EQ_BAND3_WIDTH
 452             [AUDIOHW_EQ_BAND3] = SOUND_EQ_BAND3_WIDTH,
 453         #endif
 454         #ifdef AUDIOHW_HAVE_EQ_BAND4_WIDTH
 455             [AUDIOHW_EQ_BAND4] = SOUND_EQ_BAND4_WIDTH,
 456         #endif
 457         },
 458 #endif /* AUDIOHW_HAVE_EQ_WIDTH */
 459     };
 460
 461     if (band < AUDIOHW_EQ_BAND_NUM && band_setting < AUDIOHW_EQ_SETTING_NUM)
 462         return sound_hw_eq_band_setting[band_setting][band];
 463
 464     return -1;
 465 }
 466
 467 static void sound_set_hw_eq_band_gain(unsigned int band, int value)
 468 {
 469     int setting;
 470
 471     if(!audio_is_initialized)
 472         return;
 473
 474     setting = sound_enum_hw_eq_band_setting(band, AUDIOHW_EQ_GAIN);
 475     current_eq_band_gain[band] = sound_val2phys(setting + 0x10000, value);
 476
 477     audiohw_set_eq_band_gain(band, value);
 478     set_prescaled_volume();
 479 }
 480
 481 void sound_set_hw_eq_band1_gain(int value)
 482 {
 483     sound_set_hw_eq_band_gain(AUDIOHW_EQ_BAND1, value);
 484 }
 485
 486 #if defined(AUDIOHW_HAVE_EQ_BAND2)
 487 void sound_set_hw_eq_band2_gain(int value)
 488 {
 489     sound_set_hw_eq_band_gain(AUDIOHW_EQ_BAND2, value);
 490 }
 491 #endif
 492
 493 #if defined(AUDIOHW_HAVE_EQ_BAND3)
 494 void sound_set_hw_eq_band3_gain(int value)
 495 {
 496     sound_set_hw_eq_band_gain(AUDIOHW_EQ_BAND3, value);
 497 }
 498 #endif
 499
 500 #if defined(AUDIOHW_HAVE_EQ_BAND4)
 501 void sound_set_hw_eq_band4_gain(int value)
 502 {
 503     sound_set_hw_eq_band_gain(AUDIOHW_EQ_BAND4, value);
 504 }
 505 #endif
 506
 507 #if defined(AUDIOHW_HAVE_EQ_BAND5)
 508 void sound_set_hw_eq_band5_gain(int value)
 509 {
 510     sound_set_hw_eq_band_gain(AUDIOHW_EQ_BAND5, value);
 511 }
 512 #endif
 513
 514 #if defined(AUDIOHW_HAVE_EQ_BAND1_FREQUENCY)
 515 void sound_set_hw_eq_band1_frequency(int value)
 516 {
 517     if(!audio_is_initialized)
 518         return;
 519
 520     audiohw_set_eq_band_frequency(AUDIOHW_EQ_BAND1, value);
 521 }
 522 #endif
 523
 524 #if defined(AUDIOHW_HAVE_EQ_BAND2_FREQUENCY)
 525 void sound_set_hw_eq_band2_frequency(int value)
 526 {
 527     if(!audio_is_initialized)
 528         return;
 529
 530     audiohw_set_eq_band_frequency(AUDIOHW_EQ_BAND2, value);
 531 }
 532 #endif
 533
 534 #if defined(AUDIOHW_HAVE_EQ_BAND3_FREQUENCY)
 535 void sound_set_hw_eq_band3_frequency(int value)
 536 {
 537     if(!audio_is_initialized)
 538         return;
 539
 540     audiohw_set_eq_band_frequency(AUDIOHW_EQ_BAND3, value);
 541 }
 542 #endif
 543
 544 #if defined(AUDIOHW_HAVE_EQ_BAND4_FREQUENCY)
 545 void sound_set_hw_eq_band4_frequency(int value)
 546 {
 547     if(!audio_is_initialized)
 548         return;
 549
 550     audiohw_set_eq_band_frequency(AUDIOHW_EQ_BAND4, value);
 551 }
 552 #endif
 553
 554 #if defined(AUDIOHW_HAVE_EQ_BAND5_FREQUENCY)
 555 void sound_set_hw_eq_band5_frequency(int value)
 556 {
 557     if(!audio_is_initialized)
 558         return;
 559
 560     audiohw_set_eq_band_frequency(AUDIOHW_EQ_BAND5, value);
 561 }
 562 #endif
 563
 564 #if defined(AUDIOHW_HAVE_EQ_BAND2_WIDTH)
 565 void sound_set_hw_eq_band2_width(int value)
 566 {
 567     if(!audio_is_initialized)
 568         return;
 569
 570     audiohw_set_eq_band_width(AUDIOHW_EQ_BAND2, value);
 571 }
 572 #endif
 573
 574 #if defined(AUDIOHW_HAVE_EQ_BAND3_WIDTH)
 575 void sound_set_hw_eq_band3_width(int value)
 576 {
 577     if(!audio_is_initialized)
 578         return;
 579
 580     audiohw_set_eq_band_width(AUDIOHW_EQ_BAND3, value);
 581 }
 582 #endif
 583
 584 #if defined(AUDIOHW_HAVE_EQ_BAND4_WIDTH)
 585 void sound_set_hw_eq_band4_width(int value)
 586 {
 587     if(!audio_is_initialized)
 588         return;
 589
 590     audiohw_set_eq_band_width(AUDIOHW_EQ_BAND4, value);
 591 }
 592 #endif
 593 #endif /* AUDIOHW_HAVE_EQ */
 594
 595 #if ((CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F))
 596 void sound_set_loudness(int value)
 597 {
 598     if(!audio_is_initialized)
 599         return;
 600
 601     audiohw_set_loudness(value);
 602 }
 603
 604 void sound_set_avc(int value)
 605 {
 606     if(!audio_is_initialized)
 607         return;
 608
 609     audiohw_set_avc(value);
 610 }
 611
 612 void sound_set_mdb_strength(int value)
 613 {
 614     if(!audio_is_initialized)
 615         return;
 616
 617     audiohw_set_mdb_strength(value);
 618 }
 619
 620 void sound_set_mdb_harmonics(int value)
 621 {
 622     if(!audio_is_initialized)
 623         return;
 624
 625     audiohw_set_mdb_harmonics(value);
 626 }
 627
 628 void sound_set_mdb_center(int value)
 629 {
 630     if(!audio_is_initialized)
 631         return;
 632
 633     audiohw_set_mdb_center(value);
 634 }
 635
 636 void sound_set_mdb_shape(int value)
 637 {
 638     if(!audio_is_initialized)
 639         return;
 640
 641     audiohw_set_mdb_shape(value);
 642 }
 643
 644 void sound_set_mdb_enable(int value)
 645 {
 646     if(!audio_is_initialized)
 647         return;
 648
 649     audiohw_set_mdb_enable(value);
 650 }
 651
 652 void sound_set_superbass(int value)
 653 {
 654     if(!audio_is_initialized)
 655         return;
 656
 657     audiohw_set_superbass(value);
 658 }
 659 #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */
 660
 661 void sound_set(int setting, int value)
 662 {
 663     sound_set_type* sound_set_val = sound_get_fn(setting);
 664     if (sound_set_val)
 665         sound_set_val(value);
 666 }
 667
 668 #if (!defined(HAVE_AS3514) && !defined(HAVE_WM8975) \
 669   && !defined(HAVE_WM8758) && !defined(HAVE_TSC2100) \
 670   && !defined (HAVE_WM8711) && !defined (HAVE_WM8721) \
 671   && !defined (HAVE_WM8731) && !defined (HAVE_WM8978) \
 672   && !defined (HAVE_WM8750) && !defined (HAVE_WM8751) \
 673   && !defined(HAVE_AK4537)) || (CONFIG_PLATFORM & PLATFORM_HOSTED)
 674 int sound_val2phys(int setting, int value)
 675 {
 676 #if CONFIG_CODEC == MAS3587F
 677     int result = 0;
 678
 679     switch(setting)
 680     {
 681         case SOUND_LEFT_GAIN:
 682         case SOUND_RIGHT_GAIN:
 683             result = (value - 2) * 15;
 684             break;
 685
 686         case SOUND_MIC_GAIN:
 687             result = value * 15 + 210;
 688             break;
 689
 690        default:
 691             result = value;
 692             break;
 693     }
 694     return result;
 695 #elif defined(HAVE_UDA1380)
 696     int result = 0;
 697
 698     switch(setting)
 699     {
 700 #ifdef HAVE_RECORDING
 701         case SOUND_LEFT_GAIN:
 702         case SOUND_RIGHT_GAIN:
 703         case SOUND_MIC_GAIN:
 704             result = value * 5;         /* (1/2) * 10 */
 705             break;
 706 #endif
 707         default:
 708             result = value;
 709             break;
 710     }
 711     return result;
 712 #elif defined(HAVE_TLV320) || defined(HAVE_WM8711) \
 713       || defined(HAVE_WM8721) || defined(HAVE_WM8731)
 714     int result = 0;
 715
 716     switch(setting)
 717     {
 718 #ifdef HAVE_RECORDING
 719         case SOUND_LEFT_GAIN:
 720         case SOUND_RIGHT_GAIN:
 721             result = (value - 23) * 15;    /* (x - 23)/1.5 *10 */
 722             break;
 723
 724         case SOUND_MIC_GAIN:
 725             result = value * 200;          /* 0 or 20 dB */
 726             break;
 727 #endif
 728        default:
 729             result = value;
 730             break;
 731     }
 732     return result;
 733 #elif defined(HAVE_AS3514)
 734     /* This is here for the sim only and the audio driver has its own */
 735     int result;
 736
 737     switch(setting)
 738     {
 739 #ifdef HAVE_RECORDING
 740     case SOUND_LEFT_GAIN:
 741     case SOUND_RIGHT_GAIN:
 742     case SOUND_MIC_GAIN:
 743         result = (value - 23) * 15;
 744         break;
 745 #endif
 746     default:
 747         result = value;
 748         break;
 749     }
 750
 751     return result;
 752 #elif defined(HAVE_WM8978) || defined(HAVE_WM8750) || defined(HAVE_WM8751)
 753     int result;
 754
 755     switch (setting)
 756     {
 757 #ifdef HAVE_RECORDING
 758     case SOUND_LEFT_GAIN:
 759     case SOUND_RIGHT_GAIN:
 760     case SOUND_MIC_GAIN:
 761         result = value * 5;
 762         break;
 763 #endif
 764 #ifdef AUDIOHW_HAVE_DEPTH_3D
 765     case SOUND_DEPTH_3D:
 766         result = (100 * value + 8) / 15;
 767         break;
 768 #endif
 769     default:
 770         result = value;
 771     }
 772
 773     return result;
 774 #else
 775     (void)setting;
 776     return value;
 777 #endif
 778 }
 779 #endif /* CONFIG_CODECs || PLATFORM_HOSTED */
 780
 781 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
 782 /* This function works by telling the decoder that we have another
 783    crystal frequency than we actually have. It will adjust its internal
 784    parameters and the result is that the audio is played at another pitch.
 785
 786    The pitch value precision is based on PITCH_SPEED_PRECISION (in dsp.h)
 787 */
 788
 789 static int last_pitch = PITCH_SPEED_100;
 790
 791 void sound_set_pitch(int32_t pitch)
 792 {
 793     unsigned long val;
 794
 795     if (pitch != last_pitch)
 796     {
 797         /* Calculate the new (bogus) frequency */
 798         val = 18432 * PITCH_SPEED_100 / pitch;
 799
 800         audiohw_set_pitch(val);
 801
 802         last_pitch = pitch;
 803     }
 804 }
 805
 806 int32_t sound_get_pitch(void)
 807 {
 808     return last_pitch;
 809 }
 810 #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */