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