diff options
Diffstat (limited to 'firmware')
-rw-r--r-- | firmware/drivers/audio/wm8978.c | 122 | ||||
-rw-r--r-- | firmware/export/audiohw.h | 252 | ||||
-rw-r--r-- | firmware/export/config/gigabeats.h | 3 | ||||
-rw-r--r-- | firmware/export/sound.h | 62 | ||||
-rw-r--r-- | firmware/export/wm8978.h | 13 | ||||
-rw-r--r-- | firmware/sound.c | 347 |
6 files changed, 755 insertions, 44 deletions
diff --git a/firmware/drivers/audio/wm8978.c b/firmware/drivers/audio/wm8978.c index a2dbf5a8fb..2d57ce3f10 100644 --- a/firmware/drivers/audio/wm8978.c +++ b/firmware/drivers/audio/wm8978.c | |||
@@ -37,27 +37,35 @@ extern void audiohw_enable_headphone_jack(bool enable); | |||
37 | 37 | ||
38 | const struct sound_settings_info audiohw_settings[] = | 38 | const struct sound_settings_info audiohw_settings[] = |
39 | { | 39 | { |
40 | [SOUND_VOLUME] = {"dB", 0, 1, -90, 6, -25}, | 40 | [SOUND_VOLUME] = {"dB", 0, 1, -90, 6, -25}, |
41 | [SOUND_BASS] = {"dB", 0, 1, -12, 12, 0}, | 41 | [SOUND_BALANCE] = {"%", 0, 1,-100, 100, 0}, |
42 | [SOUND_TREBLE] = {"dB", 0, 1, -12, 12, 0}, | 42 | [SOUND_CHANNELS] = {"", 0, 1, 0, 5, 0}, |
43 | [SOUND_BALANCE] = {"%", 0, 1,-100, 100, 0}, | 43 | [SOUND_STEREO_WIDTH] = {"%", 0, 5, 0, 250, 100}, |
44 | [SOUND_CHANNELS] = {"", 0, 1, 0, 5, 0}, | 44 | [SOUND_EQ_BAND1_GAIN] = {"dB", 0, 1, -12, 12, 0}, |
45 | [SOUND_STEREO_WIDTH] = {"%", 0, 5, 0, 250, 100}, | 45 | [SOUND_EQ_BAND2_GAIN] = {"dB", 0, 1, -12, 12, 0}, |
46 | [SOUND_EQ_BAND3_GAIN] = {"dB", 0, 1, -12, 12, 0}, | ||
47 | [SOUND_EQ_BAND4_GAIN] = {"dB", 0, 1, -12, 12, 0}, | ||
48 | [SOUND_EQ_BAND5_GAIN] = {"dB", 0, 1, -12, 12, 0}, | ||
49 | [SOUND_EQ_BAND1_FREQUENCY] = {"", 0, 1, 0, 3, 0}, | ||
50 | [SOUND_EQ_BAND2_FREQUENCY] = {"", 0, 1, 0, 3, 0}, | ||
51 | [SOUND_EQ_BAND3_FREQUENCY] = {"", 0, 1, 0, 3, 0}, | ||
52 | [SOUND_EQ_BAND4_FREQUENCY] = {"", 0, 1, 0, 3, 0}, | ||
53 | [SOUND_EQ_BAND5_FREQUENCY] = {"", 0, 1, 0, 3, 0}, | ||
54 | [SOUND_EQ_BAND2_WIDTH] = {"", 0, 1, 0, 1, 0}, | ||
55 | [SOUND_EQ_BAND3_WIDTH] = {"", 0, 1, 0, 1, 0}, | ||
56 | [SOUND_EQ_BAND4_WIDTH] = {"", 0, 1, 0, 1, 0}, | ||
57 | [SOUND_DEPTH_3D] = {"%", 0, 1, 0, 15, 0}, | ||
46 | #ifdef HAVE_RECORDING | 58 | #ifdef HAVE_RECORDING |
47 | /* Digital: -119.0dB to +8.0dB in 0.5dB increments | 59 | /* Digital: -119.0dB to +8.0dB in 0.5dB increments |
48 | * Analog: Relegated to volume control | 60 | * Analog: Relegated to volume control |
49 | * Circumstances unfortunately do not allow a great deal of positive | 61 | * Circumstances unfortunately do not allow a great deal of positive |
50 | * gain. */ | 62 | * gain. */ |
51 | [SOUND_LEFT_GAIN] = {"dB", 1, 1,-238, 16, 0}, | 63 | [SOUND_LEFT_GAIN] = {"dB", 1, 1,-238, 16, 0}, |
52 | [SOUND_RIGHT_GAIN] = {"dB", 1, 1,-238, 16, 0}, | 64 | [SOUND_RIGHT_GAIN] = {"dB", 1, 1,-238, 16, 0}, |
53 | #if 0 | 65 | #if 0 |
54 | [SOUND_MIC_GAIN] = {"dB", 1, 1,-238, 16, 0}, | 66 | [SOUND_MIC_GAIN] = {"dB", 1, 1,-238, 16, 0}, |
55 | #endif | 67 | #endif |
56 | #endif | 68 | #endif |
57 | #if 0 | ||
58 | [SOUND_BASS_CUTOFF] = {"", 0, 1, 1, 4, 1}, | ||
59 | [SOUND_TREBLE_CUTOFF] = {"", 0, 1, 1, 4, 1}, | ||
60 | #endif | ||
61 | }; | 69 | }; |
62 | 70 | ||
63 | static uint16_t wmc_regs[WMC_NUM_REGISTERS] = | 71 | static uint16_t wmc_regs[WMC_NUM_REGISTERS] = |
@@ -123,10 +131,20 @@ struct | |||
123 | { | 131 | { |
124 | int vol_l; | 132 | int vol_l; |
125 | int vol_r; | 133 | int vol_r; |
134 | int dac_l; | ||
135 | int dac_r; | ||
126 | bool ahw_mute; | 136 | bool ahw_mute; |
137 | int prescaler; | ||
138 | int enhance_3d_prescaler; | ||
127 | } wmc_vol = | 139 | } wmc_vol = |
128 | { | 140 | { |
129 | 0, 0, false | 141 | .vol_l = 0, |
142 | .vol_r = 0, | ||
143 | .dac_l = 0, | ||
144 | .dac_r = 0, | ||
145 | .ahw_mute = false, | ||
146 | .prescaler = 0, | ||
147 | .enhance_3d_prescaler = 0, | ||
130 | }; | 148 | }; |
131 | 149 | ||
132 | static void wmc_write(unsigned int reg, unsigned int val) | 150 | static void wmc_write(unsigned int reg, unsigned int val) |
@@ -191,6 +209,10 @@ int sound_val2phys(int setting, int value) | |||
191 | break; | 209 | break; |
192 | #endif | 210 | #endif |
193 | 211 | ||
212 | case SOUND_DEPTH_3D: | ||
213 | result = (100 * value + 8) / 15; | ||
214 | break; | ||
215 | |||
194 | default: | 216 | default: |
195 | result = value; | 217 | result = value; |
196 | } | 218 | } |
@@ -216,8 +238,12 @@ void audiohw_preinit(void) | |||
216 | wmc_set(WMC_OUT4_MONO_MIXER_CTRL, WMC_MUTE); | 238 | wmc_set(WMC_OUT4_MONO_MIXER_CTRL, WMC_MUTE); |
217 | 239 | ||
218 | /* 3. Set L/RMIXEN = 1 and DACENL/R = 1 in register R3. */ | 240 | /* 3. Set L/RMIXEN = 1 and DACENL/R = 1 in register R3. */ |
219 | wmc_write(WMC_POWER_MANAGEMENT3, | 241 | wmc_write(WMC_POWER_MANAGEMENT3, WMC_RMIXEN | WMC_LMIXEN); |
220 | WMC_RMIXEN | WMC_LMIXEN | WMC_DACENR | WMC_DACENL); | 242 | |
243 | /* EQ and 3D applied to DAC (Set before DAC enable!) */ | ||
244 | wmc_set(WMC_EQ1_LOW_SHELF, WMC_EQ3DMODE); | ||
245 | |||
246 | wmc_set(WMC_POWER_MANAGEMENT3, WMC_DACENR | WMC_DACENL); | ||
221 | 247 | ||
222 | /* 4. Set BUFIOEN = 1 and VMIDSEL[1:0] to required value in register | 248 | /* 4. Set BUFIOEN = 1 and VMIDSEL[1:0] to required value in register |
223 | * R1. Wait for VMID supply to settle */ | 249 | * R1. Wait for VMID supply to settle */ |
@@ -305,6 +331,12 @@ void audiohw_set_headphone_vol(int vol_l, int vol_r) | |||
305 | get_headphone_levels(vol_l, &dac_l, &hp_l, &mix_l, &boost_l); | 331 | get_headphone_levels(vol_l, &dac_l, &hp_l, &mix_l, &boost_l); |
306 | get_headphone_levels(vol_r, &dac_r, &hp_r, &mix_r, &boost_r); | 332 | get_headphone_levels(vol_r, &dac_r, &hp_r, &mix_r, &boost_r); |
307 | 333 | ||
334 | wmc_vol.dac_l = dac_l; | ||
335 | wmc_vol.dac_r = dac_r; | ||
336 | |||
337 | dac_l -= wmc_vol.prescaler + wmc_vol.enhance_3d_prescaler; | ||
338 | dac_r -= wmc_vol.prescaler + wmc_vol.enhance_3d_prescaler; | ||
339 | |||
308 | wmc_write_masked(WMC_LEFT_MIXER_CTRL, mix_l << WMC_BYPLMIXVOL_POS, | 340 | wmc_write_masked(WMC_LEFT_MIXER_CTRL, mix_l << WMC_BYPLMIXVOL_POS, |
309 | WMC_BYPLMIXVOL); | 341 | WMC_BYPLMIXVOL); |
310 | wmc_write_masked(WMC_LEFT_ADC_BOOST_CTRL, | 342 | wmc_write_masked(WMC_LEFT_ADC_BOOST_CTRL, |
@@ -367,6 +399,64 @@ static void audiohw_mute(bool mute) | |||
367 | } | 399 | } |
368 | } | 400 | } |
369 | 401 | ||
402 | /* Equalizer - set the eq band level -12 to +12 dB. */ | ||
403 | void audiohw_set_eq_band_gain(unsigned int band, int val) | ||
404 | { | ||
405 | if (band > 4) | ||
406 | return; | ||
407 | |||
408 | wmc_write_masked(band + WMC_EQ1_LOW_SHELF, 12 - val, WMC_EQG); | ||
409 | } | ||
410 | |||
411 | /* Equalizer - set the eq band frequency index. */ | ||
412 | void audiohw_set_eq_band_frequency(unsigned int band, int val) | ||
413 | { | ||
414 | if (band > 4) | ||
415 | return; | ||
416 | |||
417 | wmc_write_masked(band + WMC_EQ1_LOW_SHELF, | ||
418 | val << WMC_EQC_POS, WMC_EQC); | ||
419 | } | ||
420 | |||
421 | /* Equalizer - set bandwidth for peaking filters to wide (!= 0) or | ||
422 | * narrow (0); only valid for peaking filter bands 1-3. */ | ||
423 | void audiohw_set_eq_band_width(unsigned int band, int val) | ||
424 | { | ||
425 | if (band < 1 || band > 3) | ||
426 | return; | ||
427 | |||
428 | wmc_write_masked(band + WMC_EQ1_LOW_SHELF, | ||
429 | (val == 0) ? 0 : WMC_EQBW, WMC_EQBW); | ||
430 | } | ||
431 | |||
432 | /* Set prescaler to prevent clipping the output amp when applying positive | ||
433 | * gain to EQ bands. */ | ||
434 | void audiohw_set_prescaler(int val) | ||
435 | { | ||
436 | val *= 2; | ||
437 | wmc_vol.prescaler = val; | ||
438 | val += wmc_vol.enhance_3d_prescaler; /* Combine with 3D attenuation */ | ||
439 | |||
440 | wmc_write_masked(WMC_LEFT_DAC_DIGITAL_VOL, wmc_vol.dac_l - val, | ||
441 | WMC_DVOL); | ||
442 | wmc_write_masked(WMC_RIGHT_DAC_DIGITAL_VOL, wmc_vol.dac_r - val, | ||
443 | WMC_DVOL); | ||
444 | } | ||
445 | |||
446 | /* Set the depth of the 3D effect */ | ||
447 | void audiohw_set_depth_3d(int val) | ||
448 | { | ||
449 | int att = 10*val / 15; /* -5 dB @ full setting */ | ||
450 | wmc_vol.enhance_3d_prescaler = att; | ||
451 | att += wmc_vol.prescaler; /* Combine with prescaler attenuation */ | ||
452 | |||
453 | wmc_write_masked(WMC_LEFT_DAC_DIGITAL_VOL, wmc_vol.dac_l - att, | ||
454 | WMC_DVOL); | ||
455 | wmc_write_masked(WMC_RIGHT_DAC_DIGITAL_VOL, wmc_vol.dac_r - att, | ||
456 | WMC_DVOL); | ||
457 | wmc_write_masked(WMC_3D_CONTROL, val, WMC_DEPTH3D); | ||
458 | } | ||
459 | |||
370 | void audiohw_close(void) | 460 | void audiohw_close(void) |
371 | { | 461 | { |
372 | /* 1. Mute all analogue outputs */ | 462 | /* 1. Mute all analogue outputs */ |
diff --git a/firmware/export/audiohw.h b/firmware/export/audiohw.h index 22f6e68562..12c4738f7c 100644 --- a/firmware/export/audiohw.h +++ b/firmware/export/audiohw.h | |||
@@ -26,13 +26,15 @@ | |||
26 | #include <stdbool.h> | 26 | #include <stdbool.h> |
27 | 27 | ||
28 | /* define some audiohw caps */ | 28 | /* define some audiohw caps */ |
29 | #define TREBLE_CAP (1 << 0) | 29 | #define TREBLE_CAP (1 << 0) |
30 | #define BASS_CAP (1 << 1) | 30 | #define BASS_CAP (1 << 1) |
31 | #define BALANCE_CAP (1 << 2) | 31 | #define BALANCE_CAP (1 << 2) |
32 | #define CLIPPING_CAP (1 << 3) | 32 | #define CLIPPING_CAP (1 << 3) |
33 | #define PRESCALER_CAP (1 << 4) | 33 | #define PRESCALER_CAP (1 << 4) |
34 | #define BASS_CUTOFF_CAP (1 << 5) | 34 | #define BASS_CUTOFF_CAP (1 << 5) |
35 | #define TREBLE_CUTOFF_CAP (1 << 6) | 35 | #define TREBLE_CUTOFF_CAP (1 << 6) |
36 | #define EQ_CAP (1 << 7) | ||
37 | #define DEPTH_3D_CAP (1 << 8) | ||
36 | 38 | ||
37 | #ifdef HAVE_UDA1380 | 39 | #ifdef HAVE_UDA1380 |
38 | #include "uda1380.h" | 40 | #include "uda1380.h" |
@@ -75,12 +77,17 @@ | |||
75 | #define VOLUME_MAX 0 | 77 | #define VOLUME_MAX 0 |
76 | #endif | 78 | #endif |
77 | 79 | ||
80 | #ifndef AUDIOHW_NUM_TONE_CONTROLS | ||
81 | #define AUDIOHW_NUM_TONE_CONTROLS 0 | ||
82 | #endif | ||
83 | |||
78 | /* volume/balance/treble/bass interdependency main part */ | 84 | /* volume/balance/treble/bass interdependency main part */ |
79 | #define VOLUME_RANGE (VOLUME_MAX - VOLUME_MIN) | 85 | #define VOLUME_RANGE (VOLUME_MAX - VOLUME_MIN) |
80 | 86 | ||
81 | 87 | ||
82 | /* convert caps into defines */ | 88 | /* convert caps into defines */ |
83 | #ifdef AUDIOHW_CAPS | 89 | #ifdef AUDIOHW_CAPS |
90 | /* Tone controls */ | ||
84 | #if (AUDIOHW_CAPS & TREBLE_CAP) | 91 | #if (AUDIOHW_CAPS & TREBLE_CAP) |
85 | #define AUDIOHW_HAVE_TREBLE | 92 | #define AUDIOHW_HAVE_TREBLE |
86 | #endif | 93 | #endif |
@@ -89,6 +96,14 @@ | |||
89 | #define AUDIOHW_HAVE_BASS | 96 | #define AUDIOHW_HAVE_BASS |
90 | #endif | 97 | #endif |
91 | 98 | ||
99 | #if (AUDIOHW_CAPS & BASS_CUTOFF_CAP) | ||
100 | #define AUDIOHW_HAVE_BASS_CUTOFF | ||
101 | #endif | ||
102 | |||
103 | #if (AUDIOHW_CAPS & TREBLE_CUTOFF_CAP) | ||
104 | #define AUDIOHW_HAVE_TREBLE_CUTOFF | ||
105 | #endif | ||
106 | |||
92 | #if (AUDIOHW_CAPS & BALANCE_CAP) | 107 | #if (AUDIOHW_CAPS & BALANCE_CAP) |
93 | #define AUDIOHW_HAVE_BALANCE | 108 | #define AUDIOHW_HAVE_BALANCE |
94 | #endif | 109 | #endif |
@@ -101,19 +116,127 @@ | |||
101 | #define AUDIOHW_HAVE_PRESCALER | 116 | #define AUDIOHW_HAVE_PRESCALER |
102 | #endif | 117 | #endif |
103 | 118 | ||
104 | #if (AUDIOHW_CAPS & BASS_CUTOFF_CAP) | 119 | /* Hardware EQ tone controls */ |
105 | #define AUDIOHW_HAVE_BASS_CUTOFF | 120 | #if (AUDIOHW_CAPS & EQ_CAP) |
121 | /* A hardware equalizer is present (or perhaps some tone control variation | ||
122 | * that is not Bass and/or Treble) */ | ||
123 | #define AUDIOHW_HAVE_EQ | ||
124 | |||
125 | /* Defined band indexes for supported bands */ | ||
126 | enum | ||
127 | { | ||
128 | /* Band 1 is implied; bands must be contiguous, 1 to N */ | ||
129 | AUDIOHW_EQ_BAND1 = 0, | ||
130 | #define AUDIOHW_HAVE_EQ_BAND1 | ||
131 | #if (AUDIOHW_EQ_BAND_CAPS & (EQ_CAP << 1)) | ||
132 | AUDIOHW_EQ_BAND2, | ||
133 | #define AUDIOHW_HAVE_EQ_BAND2 | ||
134 | #if (AUDIOHW_EQ_BAND_CAPS & (EQ_CAP << 2)) | ||
135 | AUDIOHW_EQ_BAND3, | ||
136 | #define AUDIOHW_HAVE_EQ_BAND3 | ||
137 | #if (AUDIOHW_EQ_BAND_CAPS & (EQ_CAP << 3)) | ||
138 | AUDIOHW_EQ_BAND4, | ||
139 | #define AUDIOHW_HAVE_EQ_BAND4 | ||
140 | #if (AUDIOHW_EQ_BAND_CAPS & (EQ_CAP << 4)) | ||
141 | AUDIOHW_EQ_BAND5, | ||
142 | #define AUDIOHW_HAVE_EQ_BAND5 | ||
143 | #endif /* 5 */ | ||
144 | #endif /* 4 */ | ||
145 | #endif /* 3 */ | ||
146 | #endif /* 2 */ | ||
147 | AUDIOHW_EQ_BAND_NUM, /* Keep last */ | ||
148 | }; | ||
149 | |||
150 | #ifdef AUDIOHW_EQ_FREQUENCY_CAPS | ||
151 | /* One or more bands supports frequency cutoff or center adjustment */ | ||
152 | #define AUDIOHW_HAVE_EQ_FREQUENCY | ||
153 | enum | ||
154 | { | ||
155 | __AUDIOHW_EQ_BAND_FREQUENCY = -1, | ||
156 | #if defined(AUDIOHW_HAVE_EQ_BAND1) && \ | ||
157 | (AUDIOHW_EQ_FREQUENCY_CAPS & (EQ_CAP << 0)) | ||
158 | AUDIOHW_EQ_BAND1_FREQUENCY, | ||
159 | #define AUDIOHW_HAVE_EQ_BAND1_FREQUENCY | ||
160 | #endif | ||
161 | #if defined(AUDIOHW_HAVE_EQ_BAND2) && \ | ||
162 | (AUDIOHW_EQ_FREQUENCY_CAPS & (EQ_CAP << 1)) | ||
163 | AUDIOHW_EQ_BAND2_FREQUENCY, | ||
164 | #define AUDIOHW_HAVE_EQ_BAND2_FREQUENCY | ||
106 | #endif | 165 | #endif |
166 | #if defined(AUDIOHW_HAVE_EQ_BAND3) && \ | ||
167 | (AUDIOHW_EQ_FREQUENCY_CAPS & (EQ_CAP << 2)) | ||
168 | AUDIOHW_EQ_BAND3_FREQUENCY, | ||
169 | #define AUDIOHW_HAVE_EQ_BAND3_FREQUENCY | ||
170 | #endif | ||
171 | #if defined(AUDIOHW_HAVE_EQ_BAND4) && \ | ||
172 | (AUDIOHW_EQ_FREQUENCY_CAPS & (EQ_CAP << 3)) | ||
173 | AUDIOHW_EQ_BAND4_FREQUENCY, | ||
174 | #define AUDIOHW_HAVE_EQ_BAND4_FREQUENCY | ||
175 | #endif | ||
176 | #if defined(AUDIOHW_HAVE_EQ_BAND5) && \ | ||
177 | (AUDIOHW_EQ_FREQUENCY_CAPS & (EQ_CAP << 4)) | ||
178 | AUDIOHW_EQ_BAND5_FREQUENCY, | ||
179 | #define AUDIOHW_HAVE_EQ_BAND5_FREQUENCY | ||
180 | #endif | ||
181 | AUDIOHW_EQ_FREQUENCY_NUM, | ||
182 | }; | ||
183 | #endif /* AUDIOHW_EQ_FREQUENCY_CAPS */ | ||
184 | |||
185 | #ifdef AUDIOHW_EQ_WIDTH_CAPS | ||
186 | /* One or more bands supports bandwidth adjustment */ | ||
187 | #define AUDIOHW_HAVE_EQ_WIDTH | ||
188 | enum | ||
189 | { | ||
190 | __AUDIOHW_EQ_BAND_WIDTH = -1, | ||
191 | #if defined(AUDIOHW_HAVE_EQ_BAND1) && \ | ||
192 | (AUDIOHW_EQ_WIDTH_CAPS & (EQ_CAP << 1)) | ||
193 | AUDIOHW_EQ_BAND2_WIDTH, | ||
194 | #define AUDIOHW_HAVE_EQ_BAND2_WIDTH | ||
195 | #endif | ||
196 | #if defined(AUDIOHW_HAVE_EQ_BAND2) && \ | ||
197 | (AUDIOHW_EQ_WIDTH_CAPS & (EQ_CAP << 2)) | ||
198 | AUDIOHW_EQ_BAND3_WIDTH, | ||
199 | #define AUDIOHW_HAVE_EQ_BAND3_WIDTH | ||
200 | #endif | ||
201 | #if defined(AUDIOHW_HAVE_EQ_BAND3) && \ | ||
202 | (AUDIOHW_EQ_WIDTH_CAPS & (EQ_CAP << 3)) | ||
203 | AUDIOHW_EQ_BAND4_WIDTH, | ||
204 | #define AUDIOHW_HAVE_EQ_BAND4_WIDTH | ||
205 | #endif | ||
206 | AUDIOHW_EQ_WIDTH_NUM, /* Keep last */ | ||
207 | }; | ||
208 | #endif /* AUDIOHW_EQ_WIDTH_CAPS */ | ||
209 | |||
210 | /* Types and number of settings types (gain, frequency, width) */ | ||
211 | enum AUDIOHW_EQ_SETTINGS | ||
212 | { | ||
213 | AUDIOHW_EQ_GAIN = 0, | ||
214 | #ifdef AUDIOHW_HAVE_EQ_FREQUENCY | ||
215 | AUDIOHW_EQ_FREQUENCY, | ||
216 | #endif | ||
217 | #ifdef AUDIOHW_HAVE_EQ_WIDTH | ||
218 | AUDIOHW_EQ_WIDTH, | ||
219 | #endif | ||
220 | AUDIOHW_EQ_SETTING_NUM | ||
221 | }; | ||
107 | 222 | ||
108 | #if (AUDIOHW_CAPS & TREBLE_CUTOFF_CAP) | 223 | #endif /* (AUDIOHW_CAPS & EQ_CAP) */ |
109 | #define AUDIOHW_HAVE_TREBLE_CUTOFF | 224 | |
225 | #if (AUDIOHW_CAPS & DEPTH_3D_CAP) | ||
226 | #define AUDIOHW_HAVE_DEPTH_3D | ||
110 | #endif | 227 | #endif |
228 | |||
111 | #endif /* AUDIOHW_CAPS */ | 229 | #endif /* AUDIOHW_CAPS */ |
112 | 230 | ||
113 | enum { | 231 | enum { |
114 | SOUND_VOLUME = 0, | 232 | SOUND_VOLUME = 0, |
233 | /* Tone control */ | ||
234 | #if defined(AUDIOHW_HAVE_BASS) | ||
115 | SOUND_BASS, | 235 | SOUND_BASS, |
236 | #endif | ||
237 | #if defined(AUDIOHW_HAVE_TREBLE) | ||
116 | SOUND_TREBLE, | 238 | SOUND_TREBLE, |
239 | #endif | ||
117 | SOUND_BALANCE, | 240 | SOUND_BALANCE, |
118 | SOUND_CHANNELS, | 241 | SOUND_CHANNELS, |
119 | SOUND_STEREO_WIDTH, | 242 | SOUND_STEREO_WIDTH, |
@@ -132,12 +255,61 @@ enum { | |||
132 | SOUND_RIGHT_GAIN, | 255 | SOUND_RIGHT_GAIN, |
133 | SOUND_MIC_GAIN, | 256 | SOUND_MIC_GAIN, |
134 | #endif | 257 | #endif |
258 | /* Bass and treble tone controls */ | ||
135 | #if defined(AUDIOHW_HAVE_BASS_CUTOFF) | 259 | #if defined(AUDIOHW_HAVE_BASS_CUTOFF) |
136 | SOUND_BASS_CUTOFF, | 260 | SOUND_BASS_CUTOFF, |
137 | #endif | 261 | #endif |
138 | #if defined(AUDIOHW_HAVE_TREBLE_CUTOFF) | 262 | #if defined(AUDIOHW_HAVE_TREBLE_CUTOFF) |
139 | SOUND_TREBLE_CUTOFF, | 263 | SOUND_TREBLE_CUTOFF, |
140 | #endif | 264 | #endif |
265 | /* 3D effect */ | ||
266 | #if defined(AUDIOHW_HAVE_DEPTH_3D) | ||
267 | SOUND_DEPTH_3D, | ||
268 | #endif | ||
269 | /* Hardware EQ tone controls */ | ||
270 | /* Band gains */ | ||
271 | #if defined(AUDIOHW_HAVE_EQ) | ||
272 | /* Band 1 implied */ | ||
273 | SOUND_EQ_BAND1_GAIN, | ||
274 | #if defined(AUDIOHW_HAVE_EQ_BAND2) | ||
275 | SOUND_EQ_BAND2_GAIN, | ||
276 | #endif | ||
277 | #if defined(AUDIOHW_HAVE_EQ_BAND3) | ||
278 | SOUND_EQ_BAND3_GAIN, | ||
279 | #endif | ||
280 | #if defined(AUDIOHW_HAVE_EQ_BAND4) | ||
281 | SOUND_EQ_BAND4_GAIN, | ||
282 | #endif | ||
283 | #if defined(AUDIOHW_HAVE_EQ_BAND5) | ||
284 | SOUND_EQ_BAND5_GAIN, | ||
285 | #endif | ||
286 | /* Band frequencies */ | ||
287 | #if defined(AUDIOHW_HAVE_EQ_BAND1_FREQUENCY) | ||
288 | SOUND_EQ_BAND1_FREQUENCY, | ||
289 | #endif | ||
290 | #if defined(AUDIOHW_HAVE_EQ_BAND2_FREQUENCY) | ||
291 | SOUND_EQ_BAND2_FREQUENCY, | ||
292 | #endif | ||
293 | #if defined(AUDIOHW_HAVE_EQ_BAND3_FREQUENCY) | ||
294 | SOUND_EQ_BAND3_FREQUENCY, | ||
295 | #endif | ||
296 | #if defined(AUDIOHW_HAVE_EQ_BAND4_FREQUENCY) | ||
297 | SOUND_EQ_BAND4_FREQUENCY, | ||
298 | #endif | ||
299 | #if defined(AUDIOHW_HAVE_EQ_BAND5_FREQUENCY) | ||
300 | SOUND_EQ_BAND5_FREQUENCY, | ||
301 | #endif | ||
302 | /* Band widths */ | ||
303 | #if defined(AUDIOHW_HAVE_EQ_BAND2_WIDTH) | ||
304 | SOUND_EQ_BAND2_WIDTH, | ||
305 | #endif | ||
306 | #if defined(AUDIOHW_HAVE_EQ_BAND3_WIDTH) | ||
307 | SOUND_EQ_BAND3_WIDTH, | ||
308 | #endif | ||
309 | #if defined(AUDIOHW_HAVE_EQ_BAND4_WIDTH) | ||
310 | SOUND_EQ_BAND4_WIDTH, | ||
311 | #endif | ||
312 | #endif /* AUDIOHW_HAVE_EQ */ | ||
141 | SOUND_LAST_SETTING, /* Keep this last */ | 313 | SOUND_LAST_SETTING, /* Keep this last */ |
142 | }; | 314 | }; |
143 | 315 | ||
@@ -262,6 +434,64 @@ void audiohw_set_bass_cutoff(int val); | |||
262 | void audiohw_set_treble_cutoff(int val); | 434 | void audiohw_set_treble_cutoff(int val); |
263 | #endif | 435 | #endif |
264 | 436 | ||
437 | #ifdef AUDIOHW_HAVE_EQ | ||
438 | /** | ||
439 | * Set new band gain value. | ||
440 | * @param band index to which val is set | ||
441 | * @param val to set. | ||
442 | * NOTE: AUDIOHW_CAPS need to contain | ||
443 | * EQ_CAP | ||
444 | * | ||
445 | * AUDIOHW_EQ_BAND_CAPS must be defined as a bitmask | ||
446 | * of EQ_CAP each shifted by the zero-based band number | ||
447 | * for each band. Bands 1 to N are indexed 0 to N-1. | ||
448 | */ | ||
449 | void audiohw_set_eq_band_gain(unsigned int band, int val); | ||
450 | #endif | ||
451 | |||
452 | #ifdef AUDIOHW_HAVE_EQ_FREQUENCY | ||
453 | /** | ||
454 | * Set new band cutoff or center frequency value. | ||
455 | * @param band index to which val is set | ||
456 | * @param val to set. | ||
457 | * NOTE: AUDIOHW_CAPS need to contain | ||
458 | * EQ_CAP | ||
459 | * | ||
460 | * AUDIOHW_EQ_FREQUENCY_CAPS must be defined as a bitmask | ||
461 | * of EQ_CAP each shifted by the zero-based band number | ||
462 | * for each band that supports frequency adjustment. | ||
463 | * Bands 1 to N are indexed 0 to N-1. | ||
464 | */ | ||
465 | void audiohw_set_eq_band_frequency(unsigned int band, int val); | ||
466 | #endif | ||
467 | |||
468 | #ifdef AUDIOHW_HAVE_EQ_WIDTH | ||
469 | /** | ||
470 | * Set new band cutoff or center frequency value. | ||
471 | * @param band index to which val is set | ||
472 | * @param val to set. | ||
473 | * NOTE: AUDIOHW_CAPS need to contain | ||
474 | * EQ_CAP | ||
475 | * | ||
476 | * AUDIOHW_EQ_WIDTH_CAPS must be defined as a bitmask | ||
477 | * of EQ_CAP each shifted by the zero-based band number | ||
478 | * for each band that supports width adjustment. | ||
479 | * Bands 1 to N are indexed 0 to N-1. | ||
480 | */ | ||
481 | void audiohw_set_eq_band_width(unsigned int band, int val); | ||
482 | #endif | ||
483 | |||
484 | #ifdef AUDIOHW_HAVE_DEPTH_3D | ||
485 | /** | ||
486 | * Set new 3-d enhancement (stereo expansion) effect value. | ||
487 | * @param val to set. | ||
488 | * NOTE: AUDIOHW_CAPS need to contain | ||
489 | * DEPTH_3D_CAP | ||
490 | */ | ||
491 | void audiohw_set_depth_3d(int val); | ||
492 | #endif | ||
493 | |||
494 | |||
265 | void audiohw_set_frequency(int fsel); | 495 | void audiohw_set_frequency(int fsel); |
266 | 496 | ||
267 | #ifdef HAVE_RECORDING | 497 | #ifdef HAVE_RECORDING |
diff --git a/firmware/export/config/gigabeats.h b/firmware/export/config/gigabeats.h index 2bc56ec98c..73eb79ce90 100644 --- a/firmware/export/config/gigabeats.h +++ b/firmware/export/config/gigabeats.h | |||
@@ -90,9 +90,6 @@ | |||
90 | /* Define this if you have the WM8978 audio codec */ | 90 | /* Define this if you have the WM8978 audio codec */ |
91 | #define HAVE_WM8978 | 91 | #define HAVE_WM8978 |
92 | 92 | ||
93 | /* Tone controls for WM8978 have not been implemented yet */ | ||
94 | #define HAVE_SW_TONE_CONTROLS | ||
95 | |||
96 | /* Define bitmask of input sources - recordable bitmask can be defined | 93 | /* Define bitmask of input sources - recordable bitmask can be defined |
97 | explicitly if different */ | 94 | explicitly if different */ |
98 | #define INPUT_SRC_CAPS SRC_CAP_FMRADIO | 95 | #define INPUT_SRC_CAPS SRC_CAP_FMRADIO |
diff --git a/firmware/export/sound.h b/firmware/export/sound.h index e68ae23774..7243f48e79 100644 --- a/firmware/export/sound.h +++ b/firmware/export/sound.h | |||
@@ -55,10 +55,70 @@ void sound_set_bass(int value); | |||
55 | void sound_set_treble(int value); | 55 | void sound_set_treble(int value); |
56 | void sound_set_channels(int value); | 56 | void sound_set_channels(int value); |
57 | void sound_set_stereo_width(int value); | 57 | void sound_set_stereo_width(int value); |
58 | #if defined(HAVE_WM8758) || defined(HAVE_WM8985) | 58 | #if defined(AUDIOHW_HAVE_BASS_CUTOFF) |
59 | void sound_set_bass_cutoff(int value); | 59 | void sound_set_bass_cutoff(int value); |
60 | #endif | ||
61 | #if defined(AUDIOHW_HAVE_TREBLE_CUTOFF) | ||
60 | void sound_set_treble_cutoff(int value); | 62 | void sound_set_treble_cutoff(int value); |
61 | #endif | 63 | #endif |
64 | |||
65 | #if defined(AUDIOHW_HAVE_DEPTH_3D) | ||
66 | void sound_set_depth_3d(int value); | ||
67 | #endif | ||
68 | |||
69 | #ifdef AUDIOHW_HAVE_EQ | ||
70 | /* | ||
71 | * band = SOUND_EQ_BANDb | ||
72 | * band_setting = AUDIOHW_EQ_s | ||
73 | * | ||
74 | * Returns SOUND_EQ_BANDb_s or -1 if it doesn't exist. | ||
75 | * | ||
76 | * b: band number | ||
77 | * s: one of GAIN, FREQUENCY, WIDTH | ||
78 | */ | ||
79 | int sound_enum_hw_eq_band_setting(unsigned int band, | ||
80 | unsigned int band_setting); | ||
81 | /* Band1 implied */ | ||
82 | void sound_set_hw_eq_band1_gain(int value); | ||
83 | #ifdef AUDIOHW_HAVE_EQ_BAND1_FREQUENCY | ||
84 | void sound_set_hw_eq_band1_frequency(int value); | ||
85 | #endif | ||
86 | #ifdef AUDIOHW_HAVE_EQ_BAND2 | ||
87 | void sound_set_hw_eq_band2_gain(int value); | ||
88 | #ifdef AUDIOHW_HAVE_EQ_BAND2_FREQUENCY | ||
89 | void sound_set_hw_eq_band2_frequency(int value); | ||
90 | #endif | ||
91 | #ifdef AUDIOHW_HAVE_EQ_BAND2_WIDTH | ||
92 | void sound_set_hw_eq_band2_width(int value); | ||
93 | #endif | ||
94 | #endif /* AUDIOHW_HAVE_EQ_BAND2 */ | ||
95 | #ifdef AUDIOHW_HAVE_EQ_BAND3 | ||
96 | /* Band 3 */ | ||
97 | void sound_set_hw_eq_band3_gain(int value); | ||
98 | #ifdef AUDIOHW_HAVE_EQ_BAND3_FREQUENCY | ||
99 | void sound_set_hw_eq_band3_frequency(int value); | ||
100 | #endif | ||
101 | #if defined(AUDIOHW_HAVE_EQ_BAND3_WIDTH) | ||
102 | void sound_set_hw_eq_band3_width(int value); | ||
103 | #endif | ||
104 | #endif /* AUDIOHW_HAVE_EQ_BAND3 */ | ||
105 | #ifdef AUDIOHW_HAVE_EQ_BAND4 | ||
106 | void sound_set_hw_eq_band4_gain(int value); | ||
107 | #ifdef AUDIOHW_HAVE_EQ_BAND4_FREQUENCY | ||
108 | void sound_set_hw_eq_band4_frequency(int value); | ||
109 | #endif | ||
110 | #ifdef AUDIOHW_HAVE_EQ_BAND4_WIDTH | ||
111 | void sound_set_hw_eq_band4_width(int value); | ||
112 | #endif | ||
113 | #endif /* AUDIOHW_HAVE_EQ_BAND4 */ | ||
114 | #ifdef AUDIOHW_HAVE_EQ_BAND5 | ||
115 | void sound_set_hw_eq_band5_gain(int value); | ||
116 | #ifdef AUDIOHW_HAVE_EQ_BAND5_FREQUENCY | ||
117 | void sound_set_hw_eq_band5_frequency(int value); | ||
118 | #endif | ||
119 | #endif /* AUDIOHW_HAVE_EQ_BAND5 */ | ||
120 | #endif /* AUDIOHW_HAVE_EQ */ | ||
121 | |||
62 | #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) | 122 | #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) |
63 | void sound_set_loudness(int value); | 123 | void sound_set_loudness(int value); |
64 | void sound_set_avc(int value); | 124 | void sound_set_avc(int value); |
diff --git a/firmware/export/wm8978.h b/firmware/export/wm8978.h index 270c666a4a..4081d05a89 100644 --- a/firmware/export/wm8978.h +++ b/firmware/export/wm8978.h | |||
@@ -26,6 +26,19 @@ | |||
26 | #define VOLUME_MIN -900 | 26 | #define VOLUME_MIN -900 |
27 | #define VOLUME_MAX 60 | 27 | #define VOLUME_MAX 60 |
28 | 28 | ||
29 | #define AUDIOHW_CAPS (EQ_CAP | PRESCALER_CAP | DEPTH_3D_CAP) | ||
30 | /* Filter bitmask */ | ||
31 | #define AUDIOHW_EQ_BAND_CAPS ((EQ_CAP << 0) | (EQ_CAP << 1) | \ | ||
32 | (EQ_CAP << 2) | (EQ_CAP << 3) | \ | ||
33 | (EQ_CAP << 4)) | ||
34 | /* Filters that can adjust cutoff and center frequency */ | ||
35 | #define AUDIOHW_EQ_FREQUENCY_CAPS ((EQ_CAP << 0) | (EQ_CAP << 1) | \ | ||
36 | (EQ_CAP << 2) | (EQ_CAP << 3) | \ | ||
37 | (EQ_CAP << 4)) | ||
38 | /* Filters that can adjust band width */ | ||
39 | #define AUDIOHW_EQ_WIDTH_CAPS ((EQ_CAP << 1) | (EQ_CAP << 2) | \ | ||
40 | (EQ_CAP << 3)) | ||
41 | |||
29 | int tenthdb2master(int db); | 42 | int tenthdb2master(int db); |
30 | void audiohw_set_headphone_vol(int vol_l, int vol_r); | 43 | void audiohw_set_headphone_vol(int vol_l, int vol_r); |
31 | void audiohw_set_recsrc(int source, bool recording); | 44 | void audiohw_set_recsrc(int source, bool recording); |
diff --git a/firmware/sound.c b/firmware/sound.c index b56e610034..fb2f353d71 100644 --- a/firmware/sound.c +++ b/firmware/sound.c | |||
@@ -48,8 +48,13 @@ extern void audiohw_set_volume(int value); | |||
48 | /* dummy for sim */ | 48 | /* dummy for sim */ |
49 | const struct sound_settings_info audiohw_settings[] = { | 49 | const struct sound_settings_info audiohw_settings[] = { |
50 | [SOUND_VOLUME] = {"dB", 0, 1, VOLUME_MIN / 10, VOLUME_MAX / 10, -25}, | 50 | [SOUND_VOLUME] = {"dB", 0, 1, VOLUME_MIN / 10, VOLUME_MAX / 10, -25}, |
51 | /* Bass and treble tone controls */ | ||
52 | #ifdef AUDIOHW_HAVE_BASS | ||
51 | [SOUND_BASS] = {"dB", 0, 1, -24, 24, 0}, | 53 | [SOUND_BASS] = {"dB", 0, 1, -24, 24, 0}, |
54 | #endif | ||
55 | #ifdef AUDIOHW_HAVE_TREBLE | ||
52 | [SOUND_TREBLE] = {"dB", 0, 1, -24, 24, 0}, | 56 | [SOUND_TREBLE] = {"dB", 0, 1, -24, 24, 0}, |
57 | #endif | ||
53 | [SOUND_BALANCE] = {"%", 0, 1,-100, 100, 0}, | 58 | [SOUND_BALANCE] = {"%", 0, 1,-100, 100, 0}, |
54 | [SOUND_CHANNELS] = {"", 0, 1, 0, 5, 0}, | 59 | [SOUND_CHANNELS] = {"", 0, 1, 0, 5, 0}, |
55 | [SOUND_STEREO_WIDTH] = {"%", 0, 5, 0, 250, 100}, | 60 | [SOUND_STEREO_WIDTH] = {"%", 0, 5, 0, 250, 100}, |
@@ -64,6 +69,50 @@ const struct sound_settings_info audiohw_settings[] = { | |||
64 | #if defined(AUDIOHW_HAVE_TREBLE_CUTOFF) | 69 | #if defined(AUDIOHW_HAVE_TREBLE_CUTOFF) |
65 | [SOUND_TREBLE_CUTOFF] = {"", 0, 1, 1, 4, 1}, | 70 | [SOUND_TREBLE_CUTOFF] = {"", 0, 1, 1, 4, 1}, |
66 | #endif | 71 | #endif |
72 | #if defined(AUDIOHW_HAVE_DEPTH_3D) | ||
73 | [SOUND_DEPTH_3D] = {"%", 0, 1, 0, 15, 0}, | ||
74 | #endif | ||
75 | /* Hardware EQ tone controls */ | ||
76 | #if defined(AUDIOHW_HAVE_EQ_BAND1) | ||
77 | [SOUND_EQ_BAND1_GAIN] = {"dB", 0, 1, -12, 12, 0}, | ||
78 | #endif | ||
79 | #if defined(AUDIOHW_HAVE_EQ_BAND2) | ||
80 | [SOUND_EQ_BAND2_GAIN] = {"dB", 0, 1, -12, 12, 0}, | ||
81 | #endif | ||
82 | #if defined(AUDIOHW_HAVE_EQ_BAND3) | ||
83 | [SOUND_EQ_BAND3_GAIN] = {"dB", 0, 1, -12, 12, 0}, | ||
84 | #endif | ||
85 | #if defined(AUDIOHW_HAVE_EQ_BAND4) | ||
86 | [SOUND_EQ_BAND4_GAIN] = {"dB", 0, 1, -12, 12, 0}, | ||
87 | #endif | ||
88 | #if defined(AUDIOHW_HAVE_EQ_BAND5) | ||
89 | [SOUND_EQ_BAND5_GAIN] = {"dB", 0, 1, -12, 12, 0}, | ||
90 | #endif | ||
91 | #if defined(AUDIOHW_HAVE_EQ_BAND1_FREQUENCY) | ||
92 | [SOUND_EQ_BAND1_FREQUENCY] = {"", 0, 1, 1, 4, 1}, | ||
93 | #endif | ||
94 | #if defined(AUDIOHW_HAVE_EQ_BAND2_FREQUENCY) | ||
95 | [SOUND_EQ_BAND2_FREQUENCY] = {"", 0, 1, 1, 4, 1}, | ||
96 | #endif | ||
97 | #if defined(AUDIOHW_HAVE_EQ_BAND3_FREQUENCY) | ||
98 | [SOUND_EQ_BAND3_FREQUENCY] = {"", 0, 1, 1, 4, 1}, | ||
99 | #endif | ||
100 | #if defined(AUDIOHW_HAVE_EQ_BAND4_FREQUENCY) | ||
101 | [SOUND_EQ_BAND4_FREQUENCY] = {"", 0, 1, 1, 4, 1}, | ||
102 | #endif | ||
103 | #if defined(AUDIOHW_HAVE_EQ_BAND5_FREQUENCY) | ||
104 | [SOUND_EQ_BAND5_FREQUENCY] = {"", 0, 1, 1, 4, 1}, | ||
105 | #endif | ||
106 | #if defined(AUDIOHW_HAVE_EQ_BAND2_WIDTH) | ||
107 | [SOUND_EQ_BAND2_WIDTH] = {"", 0, 1, 0, 1, 0}, | ||
108 | #endif | ||
109 | #if defined(AUDIOHW_HAVE_EQ_BAND3_WIDTH) | ||
110 | [SOUND_EQ_BAND3_WIDTH] = {"", 0, 1, 0, 1, 0}, | ||
111 | #endif | ||
112 | #if defined(AUDIOHW_HAVE_EQ_BAND4_WIDTH) | ||
113 | [SOUND_EQ_BAND4_WIDTH] = {"", 0, 1, 0, 1, 0}, | ||
114 | #endif | ||
115 | |||
67 | #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) | 116 | #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) |
68 | [SOUND_LOUDNESS] = {"dB", 0, 1, 0, 17, 0}, | 117 | [SOUND_LOUDNESS] = {"dB", 0, 1, 0, 17, 0}, |
69 | [SOUND_AVC] = {"", 0, 1, -1, 4, 0}, | 118 | [SOUND_AVC] = {"", 0, 1, -1, 4, 0}, |
@@ -111,8 +160,12 @@ static sound_set_type * const sound_set_fns[] = | |||
111 | { | 160 | { |
112 | [0 ... SOUND_LAST_SETTING-1] = NULL, | 161 | [0 ... SOUND_LAST_SETTING-1] = NULL, |
113 | [SOUND_VOLUME] = sound_set_volume, | 162 | [SOUND_VOLUME] = sound_set_volume, |
163 | #if defined(AUDIOHW_HAVE_BASS) | ||
114 | [SOUND_BASS] = sound_set_bass, | 164 | [SOUND_BASS] = sound_set_bass, |
165 | #endif | ||
166 | #if defined(AUDIOHW_HAVE_TREBLE) | ||
115 | [SOUND_TREBLE] = sound_set_treble, | 167 | [SOUND_TREBLE] = sound_set_treble, |
168 | #endif | ||
116 | [SOUND_BALANCE] = sound_set_balance, | 169 | [SOUND_BALANCE] = sound_set_balance, |
117 | [SOUND_CHANNELS] = sound_set_channels, | 170 | [SOUND_CHANNELS] = sound_set_channels, |
118 | [SOUND_STEREO_WIDTH] = sound_set_stereo_width, | 171 | [SOUND_STEREO_WIDTH] = sound_set_stereo_width, |
@@ -132,6 +185,49 @@ static sound_set_type * const sound_set_fns[] = | |||
132 | #if defined(AUDIOHW_HAVE_TREBLE_CUTOFF) | 185 | #if defined(AUDIOHW_HAVE_TREBLE_CUTOFF) |
133 | [SOUND_TREBLE_CUTOFF] = sound_set_treble_cutoff, | 186 | [SOUND_TREBLE_CUTOFF] = sound_set_treble_cutoff, |
134 | #endif | 187 | #endif |
188 | #if defined(AUDIOHW_HAVE_DEPTH_3D) | ||
189 | [SOUND_DEPTH_3D] = sound_set_depth_3d, | ||
190 | #endif | ||
191 | /* Hardware EQ tone controls */ | ||
192 | #if defined(AUDIOHW_HAVE_EQ) | ||
193 | [SOUND_EQ_BAND1_GAIN] = sound_set_hw_eq_band1_gain, | ||
194 | #if defined(AUDIOHW_HAVE_EQ_BAND1_FREQUENCY) | ||
195 | [SOUND_EQ_BAND1_FREQUENCY] = sound_set_hw_eq_band1_frequency, | ||
196 | #endif | ||
197 | #if defined(AUDIOHW_HAVE_EQ_BAND2) | ||
198 | [SOUND_EQ_BAND2_GAIN] = sound_set_hw_eq_band2_gain, | ||
199 | #if defined(AUDIOHW_HAVE_EQ_BAND2_FREQUENCY) | ||
200 | [SOUND_EQ_BAND2_FREQUENCY] = sound_set_hw_eq_band2_frequency, | ||
201 | #endif | ||
202 | #if defined(AUDIOHW_HAVE_EQ_BAND2_WIDTH) | ||
203 | [SOUND_EQ_BAND2_WIDTH] = sound_set_hw_eq_band2_width, | ||
204 | #endif | ||
205 | #endif /* AUDIOHW_HAVE_EQ_BAND2 */ | ||
206 | #if defined(AUDIOHW_HAVE_EQ_BAND3) | ||
207 | [SOUND_EQ_BAND3_GAIN] = sound_set_hw_eq_band3_gain, | ||
208 | #if defined(AUDIOHW_HAVE_EQ_BAND3_FREQUENCY) | ||
209 | [SOUND_EQ_BAND3_FREQUENCY] = sound_set_hw_eq_band3_frequency, | ||
210 | #endif | ||
211 | #if defined(AUDIOHW_HAVE_EQ_BAND3_WIDTH) | ||
212 | [SOUND_EQ_BAND3_WIDTH] = sound_set_hw_eq_band3_width, | ||
213 | #endif | ||
214 | #endif /* AUDIOHW_HAVE_EQ_BAND3 */ | ||
215 | #if defined(AUDIOHW_HAVE_EQ_BAND4) | ||
216 | [SOUND_EQ_BAND4_GAIN] = sound_set_hw_eq_band4_gain, | ||
217 | #if defined(AUDIOHW_HAVE_EQ_BAND4_FREQUENCY) | ||
218 | [SOUND_EQ_BAND4_FREQUENCY] = sound_set_hw_eq_band4_frequency, | ||
219 | #endif | ||
220 | #if defined(AUDIOHW_HAVE_EQ_BAND4_WIDTH) | ||
221 | [SOUND_EQ_BAND4_WIDTH] = sound_set_hw_eq_band4_width, | ||
222 | #endif | ||
223 | #endif /* AUDIOHW_HAVE_EQ_BAND4 */ | ||
224 | #if defined(AUDIOHW_HAVE_EQ_BAND5) | ||
225 | [SOUND_EQ_BAND5_GAIN] = sound_set_hw_eq_band5_gain, | ||
226 | #if defined(AUDIOHW_HAVE_EQ_BAND5_FREQUENCY) | ||
227 | [SOUND_EQ_BAND5_FREQUENCY] = sound_set_hw_eq_band5_frequency, | ||
228 | #endif | ||
229 | #endif /* AUDIOHW_HAVE_EQ_BAND5 */ | ||
230 | #endif /* AUDIOHW_HAVE_EQ */ | ||
135 | }; | 231 | }; |
136 | 232 | ||
137 | sound_set_type* sound_get_fn(int setting) | 233 | sound_set_type* sound_get_fn(int setting) |
@@ -174,8 +270,15 @@ static int tenthdb2reg(int db) | |||
174 | /* all values in tenth of dB MAS3507D UDA1380 */ | 270 | /* all values in tenth of dB MAS3507D UDA1380 */ |
175 | int current_volume = 0; /* -780..+180 -840.. 0 */ | 271 | int current_volume = 0; /* -780..+180 -840.. 0 */ |
176 | int current_balance = 0; /* -960..+960 -840..+840 */ | 272 | int current_balance = 0; /* -960..+960 -840..+840 */ |
273 | #ifdef AUDIOHW_HAVE_TREBLE | ||
177 | int current_treble = 0; /* -150..+150 0.. +60 */ | 274 | int current_treble = 0; /* -150..+150 0.. +60 */ |
275 | #endif | ||
276 | #ifdef AUDIOHW_HAVE_BASS | ||
178 | int current_bass = 0; /* -150..+150 0..+240 */ | 277 | int current_bass = 0; /* -150..+150 0..+240 */ |
278 | #endif | ||
279 | #ifdef AUDIOHW_HAVE_EQ | ||
280 | int current_eq_band_gain[AUDIOHW_EQ_BAND_NUM]; | ||
281 | #endif | ||
179 | 282 | ||
180 | static void set_prescaled_volume(void) | 283 | static void set_prescaled_volume(void) |
181 | { | 284 | { |
@@ -191,10 +294,18 @@ static void set_prescaled_volume(void) | |||
191 | || defined(HAVE_WM8711) || defined(HAVE_WM8721) || defined(HAVE_WM8731) \ | 294 | || defined(HAVE_WM8711) || defined(HAVE_WM8721) || defined(HAVE_WM8731) \ |
192 | || defined(HAVE_WM8758) || defined(HAVE_WM8985) || defined(HAVE_UDA1341)) | 295 | || defined(HAVE_WM8758) || defined(HAVE_WM8985) || defined(HAVE_UDA1341)) |
193 | 296 | ||
297 | #if defined(AUDIOHW_HAVE_BASS) && defined(AUDIOHW_HAVE_TREBLE) | ||
194 | prescale = MAX(current_bass, current_treble); | 298 | prescale = MAX(current_bass, current_treble); |
299 | #endif | ||
300 | #if defined(AUDIOHW_HAVE_EQ) | ||
301 | int i; | ||
302 | for (i = 0; i < AUDIOHW_EQ_BAND_NUM; i++) | ||
303 | prescale = MAX(current_eq_band_gain[i], prescale); | ||
304 | #endif | ||
305 | |||
195 | if (prescale < 0) | 306 | if (prescale < 0) |
196 | prescale = 0; /* no need to prescale if we don't boost | 307 | prescale = 0; /* no need to prescale if we don't boost |
197 | bass or treble */ | 308 | bass, treble or eq band */ |
198 | 309 | ||
199 | /* Gain up the analog volume to compensate the prescale gain reduction, | 310 | /* Gain up the analog volume to compensate the prescale gain reduction, |
200 | * but if this would push the volume over the top, reduce prescaling | 311 | * but if this would push the volume over the top, reduce prescaling |
@@ -289,6 +400,7 @@ void sound_set_balance(int value) | |||
289 | #endif | 400 | #endif |
290 | } | 401 | } |
291 | 402 | ||
403 | #ifdef AUDIOHW_HAVE_BASS | ||
292 | void sound_set_bass(int value) | 404 | void sound_set_bass(int value) |
293 | { | 405 | { |
294 | if(!audio_is_initialized) | 406 | if(!audio_is_initialized) |
@@ -302,17 +414,19 @@ void sound_set_bass(int value) | |||
302 | #endif | 414 | #endif |
303 | #endif | 415 | #endif |
304 | 416 | ||
305 | #if defined(AUDIOHW_HAVE_BASS) | 417 | #if defined(HAVE_SW_TONE_CONTROLS) |
306 | audiohw_set_bass(value); | ||
307 | #else | ||
308 | dsp_callback(DSP_CALLBACK_SET_BASS, current_bass); | 418 | dsp_callback(DSP_CALLBACK_SET_BASS, current_bass); |
419 | #else | ||
420 | audiohw_set_bass(value); | ||
309 | #endif | 421 | #endif |
310 | 422 | ||
311 | #if !defined(AUDIOHW_HAVE_CLIPPING) | 423 | #if !defined(AUDIOHW_HAVE_CLIPPING) |
312 | set_prescaled_volume(); | 424 | set_prescaled_volume(); |
313 | #endif | 425 | #endif |
314 | } | 426 | } |
427 | #endif /* AUDIOHW_HAVE_BASS */ | ||
315 | 428 | ||
429 | #ifdef AUDIOHW_HAVE_TREBLE | ||
316 | void sound_set_treble(int value) | 430 | void sound_set_treble(int value) |
317 | { | 431 | { |
318 | if(!audio_is_initialized) | 432 | if(!audio_is_initialized) |
@@ -326,16 +440,37 @@ void sound_set_treble(int value) | |||
326 | #endif | 440 | #endif |
327 | #endif | 441 | #endif |
328 | 442 | ||
329 | #if defined(AUDIOHW_HAVE_TREBLE) | 443 | #if defined(HAVE_SW_TONE_CONTROLS) |
330 | audiohw_set_treble(value); | ||
331 | #else | ||
332 | dsp_callback(DSP_CALLBACK_SET_TREBLE, current_treble); | 444 | dsp_callback(DSP_CALLBACK_SET_TREBLE, current_treble); |
445 | #else | ||
446 | audiohw_set_treble(value); | ||
333 | #endif | 447 | #endif |
334 | 448 | ||
335 | #if !defined(AUDIOHW_HAVE_CLIPPING) | 449 | #if !defined(AUDIOHW_HAVE_CLIPPING) |
336 | set_prescaled_volume(); | 450 | set_prescaled_volume(); |
337 | #endif | 451 | #endif |
338 | } | 452 | } |
453 | #endif /* AUDIOHW_HAVE_TREBLE */ | ||
454 | |||
455 | #if defined(AUDIOHW_HAVE_BASS_CUTOFF) | ||
456 | void sound_set_bass_cutoff(int value) | ||
457 | { | ||
458 | if(!audio_is_initialized) | ||
459 | return; | ||
460 | |||
461 | audiohw_set_bass_cutoff(value); | ||
462 | } | ||
463 | #endif | ||
464 | |||
465 | #if defined(AUDIOHW_HAVE_TREBLE_CUTOFF) | ||
466 | void sound_set_treble_cutoff(int value) | ||
467 | { | ||
468 | if(!audio_is_initialized) | ||
469 | return; | ||
470 | |||
471 | audiohw_set_treble_cutoff(value); | ||
472 | } | ||
473 | #endif | ||
339 | 474 | ||
340 | void sound_set_channels(int value) | 475 | void sound_set_channels(int value) |
341 | { | 476 | { |
@@ -361,26 +496,208 @@ void sound_set_stereo_width(int value) | |||
361 | #endif | 496 | #endif |
362 | } | 497 | } |
363 | 498 | ||
364 | #if defined(AUDIOHW_HAVE_BASS_CUTOFF) | 499 | #if defined(AUDIOHW_HAVE_DEPTH_3D) |
365 | void sound_set_bass_cutoff(int value) | 500 | void sound_set_depth_3d(int value) |
366 | { | 501 | { |
367 | if(!audio_is_initialized) | 502 | if(!audio_is_initialized) |
368 | return; | 503 | return; |
369 | 504 | ||
370 | audiohw_set_bass_cutoff(value); | 505 | audiohw_set_depth_3d(value); |
371 | } | 506 | } |
372 | #endif | 507 | #endif |
373 | 508 | ||
374 | #if defined(AUDIOHW_HAVE_TREBLE_CUTOFF) | 509 | #if defined(AUDIOHW_HAVE_EQ) |
375 | void sound_set_treble_cutoff(int value) | 510 | int sound_enum_hw_eq_band_setting(unsigned int band, |
511 | unsigned int band_setting) | ||
512 | { | ||
513 | static const int8_t | ||
514 | sound_hw_eq_band_setting[AUDIOHW_EQ_SETTING_NUM][AUDIOHW_EQ_BAND_NUM] = | ||
515 | { | ||
516 | [AUDIOHW_EQ_GAIN] = | ||
517 | { | ||
518 | [0 ... AUDIOHW_EQ_BAND_NUM-1] = -1, | ||
519 | [AUDIOHW_EQ_BAND1] = SOUND_EQ_BAND1_GAIN, | ||
520 | #ifdef AUDIOHW_HAVE_EQ_BAND2 | ||
521 | [AUDIOHW_EQ_BAND2] = SOUND_EQ_BAND2_GAIN, | ||
522 | #endif | ||
523 | #ifdef AUDIOHW_HAVE_EQ_BAND3 | ||
524 | [AUDIOHW_EQ_BAND3] = SOUND_EQ_BAND3_GAIN, | ||
525 | #endif | ||
526 | #ifdef AUDIOHW_HAVE_EQ_BAND4 | ||
527 | [AUDIOHW_EQ_BAND4] = SOUND_EQ_BAND4_GAIN, | ||
528 | #endif | ||
529 | #ifdef AUDIOHW_HAVE_EQ_BAND5 | ||
530 | [AUDIOHW_EQ_BAND5] = SOUND_EQ_BAND5_GAIN, | ||
531 | #endif | ||
532 | }, | ||
533 | #ifdef AUDIOHW_HAVE_EQ_FREQUENCY | ||
534 | [AUDIOHW_EQ_FREQUENCY] = | ||
535 | { | ||
536 | [0 ... AUDIOHW_EQ_BAND_NUM-1] = -1, | ||
537 | #ifdef AUDIOHW_HAVE_EQ_BAND1_FREQUENCY | ||
538 | [AUDIOHW_EQ_BAND1] = SOUND_EQ_BAND1_FREQUENCY, | ||
539 | #endif | ||
540 | #ifdef AUDIOHW_HAVE_EQ_BAND2_FREQUENCY | ||
541 | [AUDIOHW_EQ_BAND2] = SOUND_EQ_BAND2_FREQUENCY, | ||
542 | #endif | ||
543 | #ifdef AUDIOHW_HAVE_EQ_BAND3_FREQUENCY | ||
544 | [AUDIOHW_EQ_BAND3] = SOUND_EQ_BAND3_FREQUENCY, | ||
545 | #endif | ||
546 | #ifdef AUDIOHW_HAVE_EQ_BAND4_FREQUENCY | ||
547 | [AUDIOHW_EQ_BAND4] = SOUND_EQ_BAND4_FREQUENCY, | ||
548 | #endif | ||
549 | #ifdef AUDIOHW_HAVE_EQ_BAND5_FREQUENCY | ||
550 | [AUDIOHW_EQ_BAND5] = SOUND_EQ_BAND5_FREQUENCY, | ||
551 | #endif | ||
552 | }, | ||
553 | #endif /* AUDIOHW_HAVE_EQ_FREQUENCY */ | ||
554 | #ifdef AUDIOHW_HAVE_EQ_WIDTH | ||
555 | [AUDIOHW_EQ_WIDTH] = | ||
556 | { | ||
557 | [0 ... AUDIOHW_EQ_BAND_NUM-1] = -1, | ||
558 | #ifdef AUDIOHW_HAVE_EQ_BAND2_WIDTH | ||
559 | [AUDIOHW_EQ_BAND2] = SOUND_EQ_BAND2_WIDTH, | ||
560 | #endif | ||
561 | #ifdef AUDIOHW_HAVE_EQ_BAND3_WIDTH | ||
562 | [AUDIOHW_EQ_BAND3] = SOUND_EQ_BAND3_WIDTH, | ||
563 | #endif | ||
564 | #ifdef AUDIOHW_HAVE_EQ_BAND4_WIDTH | ||
565 | [AUDIOHW_EQ_BAND4] = SOUND_EQ_BAND4_WIDTH, | ||
566 | #endif | ||
567 | }, | ||
568 | #endif /* AUDIOHW_HAVE_EQ_WIDTH */ | ||
569 | }; | ||
570 | |||
571 | if (band < AUDIOHW_EQ_BAND_NUM && band_setting < AUDIOHW_EQ_SETTING_NUM) | ||
572 | return sound_hw_eq_band_setting[band_setting][band]; | ||
573 | |||
574 | return -1; | ||
575 | } | ||
576 | |||
577 | static void sound_set_hw_eq_band_gain(unsigned int band, int value) | ||
376 | { | 578 | { |
377 | if(!audio_is_initialized) | 579 | if(!audio_is_initialized) |
378 | return; | 580 | return; |
379 | 581 | ||
380 | audiohw_set_treble_cutoff(value); | 582 | current_eq_band_gain[band] = value; |
583 | audiohw_set_eq_band_gain(band, value); | ||
584 | set_prescaled_volume(); | ||
585 | } | ||
586 | |||
587 | void sound_set_hw_eq_band1_gain(int value) | ||
588 | { | ||
589 | sound_set_hw_eq_band_gain(AUDIOHW_EQ_BAND1, value); | ||
590 | } | ||
591 | |||
592 | #if defined(AUDIOHW_HAVE_EQ_BAND2) | ||
593 | void sound_set_hw_eq_band2_gain(int value) | ||
594 | { | ||
595 | sound_set_hw_eq_band_gain(AUDIOHW_EQ_BAND2, value); | ||
596 | } | ||
597 | #endif | ||
598 | |||
599 | #if defined(AUDIOHW_HAVE_EQ_BAND3) | ||
600 | void sound_set_hw_eq_band3_gain(int value) | ||
601 | { | ||
602 | sound_set_hw_eq_band_gain(AUDIOHW_EQ_BAND3, value); | ||
381 | } | 603 | } |
382 | #endif | 604 | #endif |
383 | 605 | ||
606 | #if defined(AUDIOHW_HAVE_EQ_BAND4) | ||
607 | void sound_set_hw_eq_band4_gain(int value) | ||
608 | { | ||
609 | sound_set_hw_eq_band_gain(AUDIOHW_EQ_BAND4, value); | ||
610 | } | ||
611 | #endif | ||
612 | |||
613 | #if defined(AUDIOHW_HAVE_EQ_BAND5) | ||
614 | void sound_set_hw_eq_band5_gain(int value) | ||
615 | { | ||
616 | sound_set_hw_eq_band_gain(AUDIOHW_EQ_BAND5, value); | ||
617 | } | ||
618 | #endif | ||
619 | |||
620 | #if defined(AUDIOHW_HAVE_EQ_BAND1_FREQUENCY) | ||
621 | void sound_set_hw_eq_band1_frequency(int value) | ||
622 | { | ||
623 | if(!audio_is_initialized) | ||
624 | return; | ||
625 | |||
626 | audiohw_set_eq_band_frequency(AUDIOHW_EQ_BAND1, value); | ||
627 | } | ||
628 | #endif | ||
629 | |||
630 | #if defined(AUDIOHW_HAVE_EQ_BAND2_FREQUENCY) | ||
631 | void sound_set_hw_eq_band2_frequency(int value) | ||
632 | { | ||
633 | if(!audio_is_initialized) | ||
634 | return; | ||
635 | |||
636 | audiohw_set_eq_band_frequency(AUDIOHW_EQ_BAND2, value); | ||
637 | } | ||
638 | #endif | ||
639 | |||
640 | #if defined(AUDIOHW_HAVE_EQ_BAND3_FREQUENCY) | ||
641 | void sound_set_hw_eq_band3_frequency(int value) | ||
642 | { | ||
643 | if(!audio_is_initialized) | ||
644 | return; | ||
645 | |||
646 | audiohw_set_eq_band_frequency(AUDIOHW_EQ_BAND3, value); | ||
647 | } | ||
648 | #endif | ||
649 | |||
650 | #if defined(AUDIOHW_HAVE_EQ_BAND4_FREQUENCY) | ||
651 | void sound_set_hw_eq_band4_frequency(int value) | ||
652 | { | ||
653 | if(!audio_is_initialized) | ||
654 | return; | ||
655 | |||
656 | audiohw_set_eq_band_frequency(AUDIOHW_EQ_BAND4, value); | ||
657 | } | ||
658 | #endif | ||
659 | |||
660 | #if defined(AUDIOHW_HAVE_EQ_BAND5_FREQUENCY) | ||
661 | void sound_set_hw_eq_band5_frequency(int value) | ||
662 | { | ||
663 | if(!audio_is_initialized) | ||
664 | return; | ||
665 | |||
666 | audiohw_set_eq_band_frequency(AUDIOHW_EQ_BAND5, value); | ||
667 | } | ||
668 | #endif | ||
669 | |||
670 | #if defined(AUDIOHW_HAVE_EQ_BAND2_WIDTH) | ||
671 | void sound_set_hw_eq_band2_width(int value) | ||
672 | { | ||
673 | if(!audio_is_initialized) | ||
674 | return; | ||
675 | |||
676 | audiohw_set_eq_band_width(AUDIOHW_EQ_BAND2, value); | ||
677 | } | ||
678 | #endif | ||
679 | |||
680 | #if defined(AUDIOHW_HAVE_EQ_BAND3_WIDTH) | ||
681 | void sound_set_hw_eq_band3_width(int value) | ||
682 | { | ||
683 | if(!audio_is_initialized) | ||
684 | return; | ||
685 | |||
686 | audiohw_set_eq_band_width(AUDIOHW_EQ_BAND3, value); | ||
687 | } | ||
688 | #endif | ||
689 | |||
690 | #if defined(AUDIOHW_HAVE_EQ_BAND4_WIDTH) | ||
691 | void sound_set_hw_eq_band4_width(int value) | ||
692 | { | ||
693 | if(!audio_is_initialized) | ||
694 | return; | ||
695 | |||
696 | audiohw_set_eq_band_width(AUDIOHW_EQ_BAND4, value); | ||
697 | } | ||
698 | #endif | ||
699 | #endif /* AUDIOHW_HAVE_EQ */ | ||
700 | |||
384 | #if ((CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)) | 701 | #if ((CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)) |
385 | void sound_set_loudness(int value) | 702 | void sound_set_loudness(int value) |
386 | { | 703 | { |
@@ -572,6 +889,10 @@ int sound_val2phys(int setting, int value) | |||
572 | break; | 889 | break; |
573 | #endif | 890 | #endif |
574 | 891 | ||
892 | case SOUND_DEPTH_3D: | ||
893 | result = (100 * value + 8) / 15; | ||
894 | break; | ||
895 | |||
575 | default: | 896 | default: |
576 | result = value; | 897 | result = value; |
577 | } | 898 | } |