/*************************************************************************** * __________ __ ___. * Open \______ \ ____ ____ | | _\_ |__ _______ ___ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ * \/ \/ \/ \/ \/ * $Id$ * * Copyright (C) 2005 by Linus Nielsen Feltzing * * All files in this archive are subject to the GNU General Public License. * See the file COPYING in the source tree root for full license agreement. * * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * ****************************************************************************/ #include #include #include "config.h" #include "sound.h" #ifndef SIMULATOR #include "i2c.h" #include "mas.h" #ifdef HAVE_UDA1380 #include "uda1380.h" #elif HAVE_TLV320 #include "tlv320.h" #endif #include "dac.h" #include "system.h" #include "hwcompat.h" #if CONFIG_CODEC == SWCODEC #include "pcm_playback.h" #endif #endif #ifndef SIMULATOR extern bool audio_is_initialized; #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) extern unsigned long shadow_io_control_main; extern unsigned shadow_codec_reg0; #endif #endif /* SIMULATOR */ struct sound_settings_info { const char *unit; int numdecimals; int steps; int minval; int maxval; int defaultval; sound_set_type *setfn; }; static const struct sound_settings_info sound_settings_table[] = { [SOUND_VOLUME] = {"%", 0, 1, 0, 100, 70, sound_set_volume}, #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) [SOUND_BASS] = {"dB", 0, 1, -12, 12, 6, sound_set_bass}, [SOUND_TREBLE] = {"dB", 0, 1, -12, 12, 6, sound_set_treble}, #elif defined(HAVE_UDA1380) [SOUND_BASS] = {"dB", 0, 2, 0, 24, 0, sound_set_bass}, [SOUND_TREBLE] = {"dB", 0, 2, 0, 6, 0, sound_set_treble}, [SOUND_SCALING] = {"", 0, 1, 0, 1, SOUND_SCALE_VOLUME, sound_set_scaling}, #else /* MAS3507D */ [SOUND_BASS] = {"dB", 0, 1, -15, 15, 7, sound_set_bass}, [SOUND_TREBLE] = {"dB", 0, 1, -15, 15, 7, sound_set_treble}, #endif [SOUND_BALANCE] = {"%", 0, 1,-100, 100, 0, sound_set_balance}, [SOUND_CHANNELS] = {"", 0, 1, 0, 5, 0, sound_set_channels}, [SOUND_STEREO_WIDTH] = {"%", 0, 1, 0, 255, 100, sound_set_stereo_width}, #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) [SOUND_LOUDNESS] = {"dB", 0, 1, 0, 17, 0, sound_set_loudness}, [SOUND_AVC] = {"", 0, 1, -1, 4, 0, sound_set_avc}, [SOUND_MDB_STRENGTH] = {"dB", 0, 1, 0, 127, 48, sound_set_mdb_strength}, [SOUND_MDB_HARMONICS] = {"%", 0, 1, 0, 100, 50, sound_set_mdb_harmonics}, [SOUND_MDB_CENTER] = {"Hz", 0, 10, 20, 300, 60, sound_set_mdb_center}, [SOUND_MDB_SHAPE] = {"Hz", 0, 10, 50, 300, 90, sound_set_mdb_shape}, [SOUND_MDB_ENABLE] = {"", 0, 1, 0, 1, 0, sound_set_mdb_enable}, [SOUND_SUPERBASS] = {"", 0, 1, 0, 1, 0, sound_set_superbass}, #endif #if CONFIG_CODEC == MAS3587F [SOUND_LEFT_GAIN] = {"dB", 1, 1, 0, 15, 8, NULL}, [SOUND_RIGHT_GAIN] = {"dB", 1, 1, 0, 15, 8, NULL}, [SOUND_MIC_GAIN] = {"dB", 1, 1, 0, 15, 2, NULL}, #elif defined(HAVE_UDA1380) [SOUND_LEFT_GAIN] = {"dB", 1, 1, 0, 8, 8, NULL}, [SOUND_RIGHT_GAIN] = {"dB", 1, 1, 0, 8, 8, NULL}, [SOUND_MIC_GAIN] = {"dB", 1, 1, 0, 15, 2, NULL}, [SOUND_ADC_LEFT_GAIN] = {"dB", 1, 1,-128, 48, 0, NULL}, [SOUND_ADC_RIGHT_GAIN]= {"dB", 1, 1,-128, 48, 0, NULL}, #endif }; const char *sound_unit(int setting) { return sound_settings_table[setting].unit; } int sound_numdecimals(int setting) { return sound_settings_table[setting].numdecimals; } int sound_steps(int setting) { return sound_settings_table[setting].steps; } int sound_min(int setting) { return sound_settings_table[setting].minval; } int sound_max(int setting) { return sound_settings_table[setting].maxval; } int sound_default(int setting) { return sound_settings_table[setting].defaultval; } sound_set_type* sound_get_fn(int setting) { if ((unsigned)setting < (sizeof(sound_settings_table) / sizeof(struct sound_settings_info))) return sound_settings_table[setting].setfn; else return NULL; } #ifndef SIMULATOR #if CONFIG_CODEC == MAS3507D /* volume/balance/treble/bass interdependency */ #define VOLUME_MIN -780 #define VOLUME_MAX 180 static const unsigned int bass_table[] = { 0x9e400, /* -15dB */ 0xa2800, /* -14dB */ 0xa7400, /* -13dB */ 0xac400, /* -12dB */ 0xb1800, /* -11dB */ 0xb7400, /* -10dB */ 0xbd400, /* -9dB */ 0xc3c00, /* -8dB */ 0xca400, /* -7dB */ 0xd1800, /* -6dB */ 0xd8c00, /* -5dB */ 0xe0400, /* -4dB */ 0xe8000, /* -3dB */ 0xefc00, /* -2dB */ 0xf7c00, /* -1dB */ 0, 0x800, /* 1dB */ 0x10000, /* 2dB */ 0x17c00, /* 3dB */ 0x1f800, /* 4dB */ 0x27000, /* 5dB */ 0x2e400, /* 6dB */ 0x35800, /* 7dB */ 0x3c000, /* 8dB */ 0x42800, /* 9dB */ 0x48800, /* 10dB */ 0x4e400, /* 11dB */ 0x53800, /* 12dB */ 0x58800, /* 13dB */ 0x5d400, /* 14dB */ 0x61800 /* 15dB */ }; static const unsigned int treble_table[] = { 0xb2c00, /* -15dB */ 0xbb400, /* -14dB */ 0xc1800, /* -13dB */ 0xc6c00, /* -12dB */ 0xcbc00, /* -11dB */ 0xd0400, /* -10dB */ 0xd5000, /* -9dB */ 0xd9800, /* -8dB */ 0xde000, /* -7dB */ 0xe2800, /* -6dB */ 0xe7e00, /* -5dB */ 0xec000, /* -4dB */ 0xf0c00, /* -3dB */ 0xf5c00, /* -2dB */ 0xfac00, /* -1dB */ 0, 0x5400, /* 1dB */ 0xac00, /* 2dB */ 0x10400, /* 3dB */ 0x16000, /* 4dB */ 0x1c000, /* 5dB */ 0x22400, /* 6dB */ 0x28400, /* 7dB */ 0x2ec00, /* 8dB */ 0x35400, /* 9dB */ 0x3c000, /* 10dB */ 0x42c00, /* 11dB */ 0x49c00, /* 12dB */ 0x51800, /* 13dB */ 0x58400, /* 14dB */ 0x5f800 /* 15dB */ }; static const unsigned int prescale_table[] = { 0x80000, /* 0db */ 0x8e000, /* 1dB */ 0x9a400, /* 2dB */ 0xa5800, /* 3dB */ 0xaf400, /* 4dB */ 0xb8000, /* 5dB */ 0xbfc00, /* 6dB */ 0xc6c00, /* 7dB */ 0xcd000, /* 8dB */ 0xd25c0, /* 9dB */ 0xd7800, /* 10dB */ 0xdc000, /* 11dB */ 0xdfc00, /* 12dB */ 0xe3400, /* 13dB */ 0xe6800, /* 14dB */ 0xe9400 /* 15dB */ }; /* convert tenth of dB volume to dac3550 register value */ static int tenthdb2reg(int db) { if (db < -540) return (db + 780) / 30; else return (db + 660) / 15; } #endif #ifdef HAVE_UDA1380 /* volume/balance/treble/bass interdependency */ #define VOLUME_MIN -840 #define VOLUME_MAX 0 /* convert tenth of dB volume to master volume register value */ static int tenthdb2master(int db) { if (db < -720) /* 1.5 dB steps */ return (2940 - db) / 15; else if (db < -660) /* 0.75 dB steps */ return (1110 - db) * 2 / 15; else if (db < -520) /* 0.5 dB steps */ return (520 - db) / 5; else /* 0.25 dB steps */ return -db * 2 / 5; } static int tenthdb2mixer(int db) { if (db < -720) return 228; else if (db < -660) return 224; else if (db < -600) return 216; else if (db < -470) return (460 - db) / 5; else return -db * 2 / 5; } #endif #if (CONFIG_CODEC == MAS3507D) || defined HAVE_UDA1380 /* volume/balance/treble/bass interdependency main part */ #define VOLUME_RANGE (VOLUME_MAX - VOLUME_MIN) /* all values in tenth of dB MAS3507D UDA1380 */ int current_volume = 0; /* -780..+180 -840.. 0 */ int current_balance = 0; /* -960..+960 -840..+840 */ int current_treble = 0; /* -150..+150 0.. +60 */ int current_bass = 0; /* -150..+150 0..+240 */ #ifdef HAVE_UDA1380 #define MODIFYING_VOLUME 0 #define MODIFYING_BASS 1 #define MODIFYING_BALANCE 2 #define MODIFYING_NONE 3 int current_scaling_mode = SOUND_SCALE_VOLUME; int current_start_l_r = VOLUME_MAX; static void set_prescaled_volume_and_bass(int scaling_mode, bool just_balance) { int l = VOLUME_MAX, r = VOLUME_MAX, prescale; int new_bass = 0, new_volume = 0; if(scaling_mode == SOUND_SCALE_OFF) { if (current_volume > VOLUME_MAX) current_volume = VOLUME_MAX; new_bass = (current_bass/10) >> 1; new_volume = tenthdb2mixer(current_volume); } else if(scaling_mode == SOUND_SCALE_BASS) { if (current_volume > VOLUME_MAX) current_volume = VOLUME_MAX; prescale = ((VOLUME_MAX - current_volume) / 20); if ((current_bass + current_volume) <= VOLUME_MAX) new_bass = current_bass / 20; else new_bass = prescale; /* limit bass with volume */ new_volume = tenthdb2mixer(current_volume); } else if(scaling_mode == SOUND_SCALE_VOLUME) { prescale = current_bass; if (prescale < 0) prescale = 0; new_bass = (current_bass/10) >> 1; new_volume = prescale*2/5; if (current_volume + prescale > VOLUME_MAX) prescale = VOLUME_MAX - current_volume; l = r = current_volume + prescale; } else if(scaling_mode == SOUND_SCALE_CURRENT) { l = r = current_start_l_r; } if(!just_balance) { uda1380_set_bass(new_bass); uda1380_set_mixer_vol(new_volume, new_volume); } current_start_l_r = l; if (current_balance > 0) { l -= current_balance; if (l < VOLUME_MIN) l = VOLUME_MIN; } if (current_balance < 0) { r += current_balance; if (r < VOLUME_MIN) r = VOLUME_MIN; } uda1380_set_master_vol(tenthdb2master(l), tenthdb2master(r)); } #endif #if CONFIG_CODEC == MAS3507D static void set_prescaled_volume(void) { int prescale; int l, r; prescale = MAX(current_bass, current_treble); if (prescale < 0) prescale = 0; /* no need to prescale if we don't boost bass or treble */ mas_writereg(MAS_REG_KPRESCALE, prescale_table[prescale/10]); /* gain up the analog volume to compensate the prescale gain reduction, * but limit to the possible maximum */ if (current_volume + prescale > VOLUME_MAX) prescale = VOLUME_MAX - current_volume; l = r = current_volume + prescale; if (current_balance > 0) { l -= current_balance; if (l < VOLUME_MIN) l = VOLUME_MIN; } if (current_balance < 0) { r += current_balance; if (r < VOLUME_MIN) r = VOLUME_MIN; } dac_volume(tenthdb2reg(l), tenthdb2reg(r), false); } #endif #ifdef HAVE_UDA1380 static void set_prescaled_volume(int modifying) { if (modifying == MODIFYING_BALANCE) set_prescaled_volume_and_bass(current_scaling_mode,true); else if (current_scaling_mode == SOUND_SCALE_OFF) set_prescaled_volume_and_bass(current_scaling_mode,false); else if(( (modifying == MODIFYING_BASS) && (current_scaling_mode == SOUND_SCALE_CURRENT)) || (current_scaling_mode == SOUND_SCALE_VOLUME)) set_prescaled_volume_and_bass(SOUND_SCALE_VOLUME,false); else if(( (modifying == MODIFYING_VOLUME) && (current_scaling_mode == SOUND_SCALE_CURRENT)) || (current_scaling_mode == SOUND_SCALE_BASS)) set_prescaled_volume_and_bass(SOUND_SCALE_BASS,false); } #endif #endif /* (CONFIG_CODEC == MAS3507D) || defined HAVE_UDA1380 */ #endif /* !SIMULATOR */ int channel_configuration = SOUND_CHAN_STEREO; int stereo_width = 100; #ifndef SIMULATOR static void set_channel_config(void) { /* default values: stereo */ unsigned long val_ll = 0x80000; unsigned long val_lr = 0; unsigned long val_rl = 0; unsigned long val_rr = 0x80000; switch(channel_configuration) { /* case SOUND_CHAN_STEREO unnecessary */ case SOUND_CHAN_MONO: val_ll = 0xc0000; val_lr = 0xc0000; val_rl = 0xc0000; val_rr = 0xc0000; break; case SOUND_CHAN_CUSTOM: { /* fixed point variables (matching MAS internal format) integer part: upper 13 bits (inlcuding sign) fractional part: lower 19 bits */ long fp_width, fp_straight, fp_cross; fp_width = (stereo_width << 19) / 100; if (stereo_width <= 100) { fp_straight = - ((1<<19) + fp_width) / 2; fp_cross = fp_straight + fp_width; } else { fp_straight = - (1<<19); fp_cross = ((2 * fp_width / (((1<<19) + fp_width) >> 10)) << 9) - (1<<19); } val_ll = val_rr = fp_straight & 0xFFFFF; val_lr = val_rl = fp_cross & 0xFFFFF; } break; case SOUND_CHAN_MONO_LEFT: val_ll = 0x80000; val_lr = 0x80000; val_rl = 0; val_rr = 0; break; case SOUND_CHAN_MONO_RIGHT: val_ll = 0; val_lr = 0; val_rl = 0x80000; val_rr = 0x80000; break; case SOUND_CHAN_KARAOKE: val_ll = 0x80001; val_lr = 0x7ffff; val_rl = 0x7ffff; val_rr = 0x80001; break; } #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) mas_writemem(MAS_BANK_D0, MAS_D0_OUT_LL, &val_ll, 1); /* LL */ mas_writemem(MAS_BANK_D0, MAS_D0_OUT_LR, &val_lr, 1); /* LR */ mas_writemem(MAS_BANK_D0, MAS_D0_OUT_RL, &val_rl, 1); /* RL */ mas_writemem(MAS_BANK_D0, MAS_D0_OUT_RR, &val_rr, 1); /* RR */ #elif CONFIG_CODEC == MAS3507D mas_writemem(MAS_BANK_D1, 0x7f8, &val_ll, 1); /* LL */ mas_writemem(MAS_BANK_D1, 0x7f9, &val_lr, 1); /* LR */ mas_writemem(MAS_BANK_D1, 0x7fa, &val_rl, 1); /* RL */ mas_writemem(MAS_BANK_D1, 0x7fb, &val_rr, 1); /* RR */ #endif } #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) unsigned long mdb_shape_shadow = 0; unsigned long loudness_shadow = 0; #endif void sound_set_volume(int value) { if(!audio_is_initialized) return; #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) int tmp = 0x7f00 * value / 100; mas_codec_writereg(0x10, tmp & 0xff00); #elif (CONFIG_CODEC == MAS3507D) current_volume = VOLUME_MIN + (value * VOLUME_RANGE / 100); set_prescaled_volume(); /* tenth of dB */ #elif defined HAVE_UDA1380 current_volume = VOLUME_MIN + (value * VOLUME_RANGE / 100); set_prescaled_volume(MODIFYING_VOLUME); /* tenth of dB */ #elif (CONFIG_CPU == PP5020) /* TODO: Implement sound_set_volume() */ (void)value; #endif } void sound_set_balance(int value) { if(!audio_is_initialized) return; #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) int tmp = ((value * 127 / 100) & 0xff) << 8; mas_codec_writereg(0x11, tmp & 0xff00); #elif CONFIG_CODEC == MAS3507D current_balance = value * VOLUME_RANGE / 100; /* tenth of dB */ set_prescaled_volume(); #elif defined HAVE_UDA1380 current_balance = value * VOLUME_RANGE / 100; /* tenth of dB */ set_prescaled_volume(MODIFYING_BALANCE); #elif (CONFIG_CPU == PP5020) /* TODO: Implement sound_set_balance() */ (void)value; #endif } void sound_set_bass(int value) { if(!audio_is_initialized) return; #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) int tmp = ((value * 8) & 0xff) << 8; mas_codec_writereg(0x14, tmp & 0xff00); #elif CONFIG_CODEC == MAS3507D mas_writereg(MAS_REG_KBASS, bass_table[value+15]); current_bass = value * 10; set_prescaled_volume(); #elif defined(HAVE_UDA1380) current_bass = value * 10; set_prescaled_volume(MODIFYING_BASS); #elif (CONFIG_CPU == PP5020) /* TODO: Implement sound_set_bass() */ (void)value; #endif } void sound_set_treble(int value) { if(!audio_is_initialized) return; #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) int tmp = ((value * 8) & 0xff) << 8; mas_codec_writereg(0x15, tmp & 0xff00); #elif CONFIG_CODEC == MAS3507D mas_writereg(MAS_REG_KTREBLE, treble_table[value+15]); current_treble = value * 10; set_prescaled_volume(); #elif defined(HAVE_UDA1380) uda1380_set_treble(value >> 1); current_treble = value * 10; #elif (CONFIG_CPU == PP5020) /* TODO: Implement sound_set_treble() */ (void)value; #endif } void sound_set_channels(int value) { if(!audio_is_initialized) return; channel_configuration = value; set_channel_config(); } void sound_set_stereo_width(int value) { if(!audio_is_initialized) return; stereo_width = value; if (channel_configuration == SOUND_CHAN_CUSTOM) set_channel_config(); } #ifdef HAVE_UDA1380 void sound_set_scaling(int value) { current_scaling_mode = value; if(!audio_is_initialized) return; set_prescaled_volume(MODIFYING_NONE); } #endif #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) void sound_set_loudness(int value) { if(!audio_is_initialized) return; loudness_shadow = (loudness_shadow & 0x04) | (MAX(MIN(value * 4, 0x44), 0) << 8); mas_codec_writereg(MAS_REG_KLOUDNESS, loudness_shadow); } void sound_set_avc(int value) { if(!audio_is_initialized) return; int tmp; switch (value) { case 1: /* 20ms */ tmp = (0x1 << 8) | (0x8 << 12); break; case 2: /* 2s */ tmp = (0x2 << 8) | (0x8 << 12); break; case 3: /* 4s */ tmp = (0x4 << 8) | (0x8 << 12); break; case 4: /* 8s */ tmp = (0x8 << 8) | (0x8 << 12); break; case -1: /* turn off and then turn on again to decay quickly */ tmp = mas_codec_readreg(MAS_REG_KAVC); mas_codec_writereg(MAS_REG_KAVC, 0); break; default: /* off */ tmp = 0; break; } mas_codec_writereg(MAS_REG_KAVC, tmp); } void sound_set_mdb_strength(int value) { if(!audio_is_initialized) return; mas_codec_writereg(MAS_REG_KMDB_STR, (value & 0x7f) << 8); } void sound_set_mdb_harmonics(int value) { if(!audio_is_initialized) return; int tmp = value * 127 / 100; mas_codec_writereg(MAS_REG_KMDB_HAR, (tmp & 0x7f) << 8); } void sound_set_mdb_center(int value) { if(!audio_is_initialized) return; mas_codec_writereg(MAS_REG_KMDB_FC, (value/10) << 8); } void sound_set_mdb_shape(int value) { if(!audio_is_initialized) return; mdb_shape_shadow = (mdb_shape_shadow & 0x02) | ((value/10) << 8); mas_codec_writereg(MAS_REG_KMDB_SWITCH, mdb_shape_shadow); } void sound_set_mdb_enable(int value) { if(!audio_is_initialized) return; mdb_shape_shadow = (mdb_shape_shadow & ~0x02) | (value?2:0); mas_codec_writereg(MAS_REG_KMDB_SWITCH, mdb_shape_shadow); } void sound_set_superbass(int value) { if(!audio_is_initialized) return; loudness_shadow = (loudness_shadow & ~0x04) | (value?4:0); mas_codec_writereg(MAS_REG_KLOUDNESS, loudness_shadow); } #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */ #else /* SIMULATOR */ void sound_set_volume(int value) { (void)value; } void sound_set_balance(int value) { (void)value; } void sound_set_bass(int value) { (void)value; } void sound_set_treble(int value) { (void)value; } void sound_set_channels(int value) { (void)value; } void sound_set_stereo_width(int value) { (void)value; } #ifdef HAVE_UDA1380 void sound_set_scaling(int value) { (void)value; } #endif #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) void sound_set_loudness(int value) { (void)value; } void sound_set_avc(int value) { (void)value; } void sound_set_mdb_strength(int value) { (void)value; } void sound_set_mdb_harmonics(int value) { (void)value; } void sound_set_mdb_center(int value) { (void)value; } void sound_set_mdb_shape(int value) { (void)value; } void sound_set_mdb_enable(int value) { (void)value; } void sound_set_superbass(int value) { (void)value; } #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */ #endif /* SIMULATOR */ void sound_set(int setting, int value) { sound_set_type* sound_set_val = sound_get_fn(setting); if (sound_set_val) sound_set_val(value); } int sound_val2phys(int setting, int value) { #if CONFIG_CODEC == MAS3587F int result = 0; switch(setting) { case SOUND_LEFT_GAIN: case SOUND_RIGHT_GAIN: result = (value - 2) * 15; break; case SOUND_MIC_GAIN: result = value * 15 + 210; break; default: result = value; break; } return result; #elif defined(HAVE_UDA1380) int result = 0; switch(setting) { case SOUND_LEFT_GAIN: case SOUND_RIGHT_GAIN: result = value * 30; /* (24/8) *10 */ break; case SOUND_MIC_GAIN: result = value * 20; /* (30/15) *10 */ break; case SOUND_ADC_LEFT_GAIN: case SOUND_ADC_RIGHT_GAIN: result = value * 5; /* (1/2) *10 */ break; default: result = value; break; } return result; #else (void)setting; return value; #endif } #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) #ifndef SIMULATOR /* This function works by telling the decoder that we have another crystal frequency than we actually have. It will adjust its internal parameters and the result is that the audio is played at another pitch. The pitch value is in tenths of percent. */ static int last_pitch = 1000; void sound_set_pitch(int pitch) { unsigned long val; if (pitch != last_pitch) { /* Calculate the new (bogus) frequency */ val = 18432 * 1000 / pitch; mas_writemem(MAS_BANK_D0, MAS_D0_OFREQ_CONTROL, &val, 1); /* We must tell the MAS that the frequency has changed. * This will unfortunately cause a short silence. */ mas_writemem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &shadow_io_control_main, 1); last_pitch = pitch; } } int sound_get_pitch(void) { return last_pitch; } #else /* SIMULATOR */ void sound_set_pitch(int pitch) { (void)pitch; } int sound_get_pitch(void) { return 1000; } #endif /* SIMULATOR */ #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */