0ea71be348
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@8146 a1c6a512-1295-4272-9138-f99709370657
881 lines
23 KiB
C
881 lines
23 KiB
C
/***************************************************************************
|
|
* __________ __ ___.
|
|
* 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 <stdbool.h>
|
|
#include <stdio.h>
|
|
#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) */
|