/* * Copyright (C) 2017 Jared Boone, ShareBrained Technology, Inc. * * This file is part of PortaPack. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; see the file COPYING. If not, write to * the Free Software Foundation, Inc., 51 Franklin Street, * Boston, MA 02110-1301, USA. */ #ifndef __AK4951_H__ #define __AK4951_H__ #include <cstdint> #include <array> #include "utility.hpp" #include "i2c_pp.hpp" #include "audio.hpp" namespace asahi_kasei { namespace ak4951 { using address_t = uint8_t; using reg_t = uint8_t; constexpr size_t reg_count = 0x50; enum class Register : address_t { PowerManagement1 = 0x00, PowerManagement2 = 0x01, SignalSelect1 = 0x02, SignalSelect2 = 0x03, SignalSelect3 = 0x04, ModeControl1 = 0x05, ModeControl2 = 0x06, ModeControl3 = 0x07, DigitalMic = 0x08, TimerSelect = 0x09, ALCTimerSelect = 0x0a, ALCModeControl1 = 0x0b, ALCModeControl2 = 0x0c, LchInputVolumeControl = 0x0d, RchInputVolumeControl = 0x0e, ALCVolume = 0x0f, _Reserved_0x10 = 0x10, RchMicGainSetting = 0x11, BeepControl = 0x12, LchDigitalVolumeControl = 0x13, RchDigitalVolumeControl = 0x14, EQCommonGainSelect = 0x15, EQ2CommonGainSetting = 0x16, EQ3CommonGainSetting = 0x17, EQ4CommonGainSetting = 0x18, EQ5CommonGainSetting = 0x19, AutoHPFControl = 0x1a, DigitalFilterSelect1 = 0x1b, DigitalFilterSelect2 = 0x1c, DigitalFilterMode = 0x1d, HPF2Coefficient0 = 0x1e, HPF2Coefficient1 = 0x1f, HPF2Coefficient2 = 0x20, HPF2Coefficient3 = 0x21, LPFCoefficient0 = 0x22, LPFCoefficient1 = 0x23, LPFCoefficient2 = 0x24, LPFCoefficient3 = 0x25, FIL3Coefficient0 = 0x26, FIL3Coefficient1 = 0x27, FIL3Coefficient2 = 0x28, FIL3Coefficient3 = 0x29, EQCoefficient0 = 0x2a, EQCoefficient1 = 0x2b, EQCoefficient2 = 0x2c, EQCoefficient3 = 0x2d, EQCoefficient4 = 0x2e, EQCoefficient5 = 0x2f, DigitalFilterSelect3 = 0x30, DeviceInformation = 0x31, E1Coefficient0 = 0x32, E1Coefficient1 = 0x33, E1Coefficient2 = 0x34, E1Coefficient3 = 0x35, E1Coefficient4 = 0x36, E1Coefficient5 = 0x37, E2Coefficient0 = 0x38, E2Coefficient1 = 0x39, E2Coefficient2 = 0x3a, E2Coefficient3 = 0x3b, E2Coefficient4 = 0x3c, E2Coefficient5 = 0x3d, E3Coefficient0 = 0x3e, E3Coefficient1 = 0x3f, E3Coefficient2 = 0x40, E3Coefficient3 = 0x41, E3Coefficient4 = 0x42, E3Coefficient5 = 0x43, E4Coefficient0 = 0x44, E4Coefficient1 = 0x45, E4Coefficient2 = 0x46, E4Coefficient3 = 0x47, E4Coefficient4 = 0x48, E4Coefficient5 = 0x49, E5Coefficient0 = 0x4a, E5Coefficient1 = 0x4b, E5Coefficient2 = 0x4c, E5Coefficient3 = 0x4d, E5Coefficient4 = 0x4e, E5Coefficient5 = 0x4f, _count, }; static_assert(toUType(Register::_count) == reg_count, "Register::_count != reg_count"); struct PowerManagement1 { reg_t PMADL : 1; reg_t PMADR : 1; reg_t PMDAC : 1; reg_t reserved0 : 2; reg_t PMBP : 1; reg_t PMVCM : 1; reg_t PMPFIL : 1; }; static_assert(sizeof(PowerManagement1) == sizeof(reg_t), "wrong size `struct"); struct PowerManagement2 { reg_t LOSEL : 1; reg_t PMSL : 1; reg_t PMPLL : 1; reg_t MS : 1; reg_t PMHPL : 1; reg_t PMHPR : 1; reg_t reserved0 : 1; reg_t PMOSC : 1; }; static_assert(sizeof(PowerManagement2) == sizeof(reg_t), "wrong size struct"); struct SignalSelect1 { reg_t MGAIN20 : 3; reg_t PMMP : 1; reg_t MPSEL : 1; reg_t DACS : 1; reg_t MGAIN3 : 1; reg_t SLPSN : 1; }; static_assert(sizeof(SignalSelect1) == sizeof(reg_t), "wrong size struct"); struct SignalSelect2 { reg_t INR : 2; reg_t INL : 2; reg_t MICL : 1; reg_t reserved0 : 1; reg_t SPKG : 2; }; static_assert(sizeof(SignalSelect2) == sizeof(reg_t), "wrong size struct"); struct SignalSelect3 { reg_t MONO : 2; reg_t PTS : 2; reg_t reserved0 : 1; reg_t DACL : 1; reg_t LVCM : 2; }; static_assert(sizeof(SignalSelect3) == sizeof(reg_t), "wrong size struct"); struct ModeControl1 { reg_t DIF : 2; reg_t CKOFF : 1; reg_t BCKO : 1; reg_t PLL : 4; }; static_assert(sizeof(ModeControl1) == sizeof(reg_t), "wrong size struct"); struct ModeControl2 { reg_t FS : 4; reg_t reserved0 : 2; reg_t CM : 2; }; static_assert(sizeof(ModeControl2) == sizeof(reg_t), "wrong size struct"); struct ModeControl3 { reg_t reserved0 : 2; reg_t IVOLC : 1; reg_t reserved1 : 1; reg_t DVOLC : 1; reg_t SMUTE : 1; reg_t THDET : 1; reg_t TSDSEL : 1; }; static_assert(sizeof(ModeControl3) == sizeof(reg_t), "wrong size struct"); struct DigitalMIC { reg_t DMIC : 1; reg_t DCLKP : 1; reg_t reserved0 : 1; reg_t DCLKE : 1; reg_t PMDML : 1; reg_t PMDMR : 1; reg_t reserved1 : 1; reg_t READ : 1; }; static_assert(sizeof(DigitalMIC) == sizeof(reg_t), "wrong size struct"); struct TimerSelect { reg_t DVTM : 1; reg_t MOFF : 1; reg_t reserved0 : 2; reg_t FRN : 1; reg_t FRATT : 1; reg_t ADRST : 2; }; static_assert(sizeof(TimerSelect) == sizeof(reg_t), "wrong size struct"); struct ALCTimerSelect { reg_t RFST : 2; reg_t WTM : 2; reg_t EQFC : 2; reg_t IVTM : 1; reg_t reserved0 : 1; }; static_assert(sizeof(ALCTimerSelect) == sizeof(reg_t), "wrong size struct"); struct ALCModeControl1 { reg_t LMTH10 : 2; reg_t RGAIN : 3; reg_t ALC : 1; reg_t LMTH2 : 1; reg_t ALCEQN : 1; }; static_assert(sizeof(ALCModeControl1) == sizeof(reg_t), "wrong size struct"); struct ALCModeControl2 { reg_t REF : 8; }; static_assert(sizeof(ALCModeControl2) == sizeof(reg_t), "wrong size struct"); struct InputVolumeControl { reg_t IV : 8; }; static_assert(sizeof(InputVolumeControl) == sizeof(reg_t), "wrong size struct"); using LchInputVolumeControl = InputVolumeControl; using RchInputVolumeControl = InputVolumeControl; struct ALCVolume { reg_t VOL : 8; }; static_assert(sizeof(ALCVolume) == sizeof(reg_t), "wrong size struct"); struct RchMICGainSetting { reg_t MGR : 8; }; static_assert(sizeof(RchMICGainSetting) == sizeof(reg_t), "wrong size struct"); struct BeepControl { reg_t BPLVL : 4; reg_t BEEPH : 1; reg_t BEEPS : 1; reg_t BPVCM : 1; reg_t HPZ : 1; }; static_assert(sizeof(BeepControl) == sizeof(reg_t), "wrong size struct"); struct DigitalVolumeControl { reg_t DV : 8; }; static_assert(sizeof(DigitalVolumeControl) == sizeof(reg_t), "wrong size struct"); using LchDigitalVolumeControl = DigitalVolumeControl; using RchDigitalVolumeControl = DigitalVolumeControl; struct EQCommonGainSelect { reg_t reserved0 : 1; reg_t EQC2 : 1; reg_t EQC3 : 1; reg_t EQC4 : 1; reg_t EQC5 : 1; reg_t reserved1 : 3; }; static_assert(sizeof(EQCommonGainSelect) == sizeof(reg_t), "wrong size struct"); struct EQCommonGainSetting { reg_t EQnT : 2; reg_t EQnG : 6; }; static_assert(sizeof(EQCommonGainSetting) == sizeof(reg_t), "wrong size struct"); using EQ2CommonGainSetting = EQCommonGainSetting; using EQ3CommonGainSetting = EQCommonGainSetting; using EQ4CommonGainSetting = EQCommonGainSetting; using EQ5CommonGainSetting = EQCommonGainSetting; struct AutoHPFControl { reg_t STG : 2; reg_t SENC : 3; reg_t AHPF : 1; reg_t reserved0 : 2; }; static_assert(sizeof(AutoHPFControl) == sizeof(reg_t), "wrong size struct"); struct DigitalFilterSelect1 { reg_t HPFAD : 1; reg_t HPFC : 2; reg_t reserved0 : 5; }; static_assert(sizeof(DigitalFilterSelect1) == sizeof(reg_t), "wrong size struct"); struct DigitalFilterSelect2 { reg_t HPF : 1; reg_t LPF : 1; reg_t reserved0 : 2; reg_t FIL3 : 1; reg_t EQ0 : 1; reg_t GN : 2; }; static_assert(sizeof(DigitalFilterSelect2) == sizeof(reg_t), "wrong size struct"); struct DigitalFilterMode { reg_t PFSDO : 1; reg_t ADCPF : 1; reg_t PFDAC : 2; reg_t PFVOL : 2; reg_t reserved0 : 2; }; static_assert(sizeof(DigitalFilterMode) == sizeof(reg_t), "wrong size struct"); struct Coefficient14L { reg_t l : 8; }; struct Coefficient14H { reg_t h : 6; reg_t reserved0 : 2; }; static_assert(sizeof(Coefficient14L) == sizeof(reg_t), "wrong size struct"); static_assert(sizeof(Coefficient14H) == sizeof(reg_t), "wrong size struct"); using Coefficient16L = Coefficient14L; struct Coefficient16H { reg_t h : 8; }; static_assert(sizeof(Coefficient16H) == sizeof(reg_t), "wrong size struct"); using HPF2Coefficient0 = Coefficient14L; using HPF2Coefficient1 = Coefficient14H; using HPF2Coefficient2 = Coefficient14L; using HPF2Coefficient3 = Coefficient14H; using LPFCoefficient0 = Coefficient14L; using LPFCoefficient1 = Coefficient14H; using LPFCoefficient2 = Coefficient14L; using LPFCoefficient3 = Coefficient14H; using FIL3Coefficient0 = Coefficient14L; struct FIL3Coefficient1 { reg_t h : 6; reg_t reserved0 : 1; reg_t s : 1; }; static_assert(sizeof(FIL3Coefficient1) == sizeof(reg_t), "wrong size struct"); using FIL3Coefficient2 = Coefficient14L; using FIL3Coefficient3 = Coefficient14H; using EQCoefficient0 = Coefficient16L; using EQCoefficient1 = Coefficient16H; using EQCoefficient2 = Coefficient14L; using EQCoefficient3 = Coefficient14H; using EQCoefficient4 = Coefficient16L; using EQCoefficient5 = Coefficient16H; struct DigitalFilterSelect3 { reg_t EQ1 : 1; reg_t EQ2 : 1; reg_t EQ3 : 1; reg_t EQ4 : 1; reg_t EQ5 : 1; reg_t reserved0 : 3; }; static_assert(sizeof(DigitalFilterSelect3) == sizeof(reg_t), "wrong size struct"); struct DeviceInformation { reg_t DVN : 4; reg_t REV : 4; }; static_assert(sizeof(DeviceInformation) == sizeof(reg_t), "wrong size struct"); using E1Coefficient0 = Coefficient16L; using E1Coefficient1 = Coefficient16H; using E1Coefficient2 = Coefficient16L; using E1Coefficient3 = Coefficient16H; using E1Coefficient4 = Coefficient16L; using E1Coefficient5 = Coefficient16H; using E2Coefficient0 = Coefficient16L; using E2Coefficient1 = Coefficient16H; using E2Coefficient2 = Coefficient16L; using E2Coefficient3 = Coefficient16H; using E2Coefficient4 = Coefficient16L; using E2Coefficient5 = Coefficient16H; using E3Coefficient0 = Coefficient16L; using E3Coefficient1 = Coefficient16H; using E3Coefficient2 = Coefficient16L; using E3Coefficient3 = Coefficient16H; using E3Coefficient4 = Coefficient16L; using E3Coefficient5 = Coefficient16H; using E4Coefficient0 = Coefficient16L; using E4Coefficient1 = Coefficient16H; using E4Coefficient2 = Coefficient16L; using E4Coefficient3 = Coefficient16H; using E4Coefficient4 = Coefficient16L; using E4Coefficient5 = Coefficient16H; using E5Coefficient0 = Coefficient16L; using E5Coefficient1 = Coefficient16H; using E5Coefficient2 = Coefficient16L; using E5Coefficient3 = Coefficient16H; using E5Coefficient4 = Coefficient16L; using E5Coefficient5 = Coefficient16H; struct Register_Type { PowerManagement1 power_management_1; PowerManagement2 power_management_2; SignalSelect1 signal_select_1; SignalSelect2 signal_select_2; SignalSelect3 signal_select_3; ModeControl1 mode_control_1; ModeControl2 mode_control_2; ModeControl3 mode_control_3; DigitalMIC digital_mic; TimerSelect timer_select; ALCTimerSelect alc_timer_select; ALCModeControl1 alc_mode_control_1; ALCModeControl2 alc_mode_control_2; LchInputVolumeControl l_ch_input_volume_control; RchInputVolumeControl r_ch_input_volume_control; ALCVolume alc_volume; reg_t _reserved_0x10; RchMICGainSetting r_ch_mic_gain_setting; BeepControl beep_control; LchDigitalVolumeControl l_ch_digital_volume_control; RchDigitalVolumeControl r_ch_digital_volume_control; EQCommonGainSelect eq_common_gain_select; EQ2CommonGainSetting eq2_common_gain_setting; EQ3CommonGainSetting eq3_common_gain_setting; EQ4CommonGainSetting eq4_common_gain_setting; EQ5CommonGainSetting eq5_common_gain_setting; AutoHPFControl auto_hpf_control; DigitalFilterSelect1 digital_filter_select_1; DigitalFilterSelect2 digital_filter_select_2; DigitalFilterMode digital_filter_mode; HPF2Coefficient0 hpf_2_coefficient_0; HPF2Coefficient1 hpf_2_coefficient_1; HPF2Coefficient2 hpf_2_coefficient_2; HPF2Coefficient3 hpf_2_coefficient_3; LPFCoefficient0 lpf_coefficient_0; LPFCoefficient1 lpf_coefficient_1; LPFCoefficient2 lpf_coefficient_2; LPFCoefficient3 lpf_coefficient_3; FIL3Coefficient0 fil_3_coefficient_0; FIL3Coefficient1 fil_3_coefficient_1; FIL3Coefficient2 fil_3_coefficient_2; FIL3Coefficient3 fil_3_coefficient_3; EQCoefficient0 eq_coefficient_0; EQCoefficient1 eq_coefficient_1; EQCoefficient2 eq_coefficient_2; EQCoefficient3 eq_coefficient_3; EQCoefficient4 eq_coefficient_4; EQCoefficient5 eq_coefficient_5; DigitalFilterSelect3 digital_filter_select_3; DeviceInformation device_information; E1Coefficient0 e1_coefficient_0; E1Coefficient1 e1_coefficient_1; E1Coefficient2 e1_coefficient_2; E1Coefficient3 e1_coefficient_3; E1Coefficient4 e1_coefficient_4; E1Coefficient5 e1_coefficient_5; E2Coefficient0 e2_coefficient_0; E2Coefficient1 e2_coefficient_1; E2Coefficient2 e2_coefficient_2; E2Coefficient3 e2_coefficient_3; E2Coefficient4 e2_coefficient_4; E2Coefficient5 e2_coefficient_5; E3Coefficient0 e3_coefficient_0; E3Coefficient1 e3_coefficient_1; E3Coefficient2 e3_coefficient_2; E3Coefficient3 e3_coefficient_3; E3Coefficient4 e3_coefficient_4; E3Coefficient5 e3_coefficient_5; E4Coefficient0 e4_coefficient_0; E4Coefficient1 e4_coefficient_1; E4Coefficient2 e4_coefficient_2; E4Coefficient3 e4_coefficient_3; E4Coefficient4 e4_coefficient_4; E4Coefficient5 e4_coefficient_5; E5Coefficient0 e5_coefficient_0; E5Coefficient1 e5_coefficient_1; E5Coefficient2 e5_coefficient_2; E5Coefficient3 e5_coefficient_3; E5Coefficient4 e5_coefficient_4; E5Coefficient5 e5_coefficient_5; }; static_assert(sizeof(Register_Type) == reg_count * sizeof(reg_t), "Register_Type wrong size"); struct RegisterMap { constexpr RegisterMap( Register_Type values ) : r(values) { } union { Register_Type r; std::array<reg_t, reg_count> w; }; }; static_assert(sizeof(RegisterMap) == reg_count * sizeof(reg_t), "RegisterMap type wrong size"); constexpr RegisterMap default_after_reset { Register_Type { .power_management_1 = { .PMADL = 0, .PMADR = 0, .PMDAC = 0, .reserved0 = 0, .PMBP = 0, .PMVCM = 0, .PMPFIL = 0, }, .power_management_2 = { .LOSEL = 0, .PMSL = 0, .PMPLL = 0, .MS = 0, .PMHPL = 0, .PMHPR = 0, .reserved0 = 0, .PMOSC = 0, }, .signal_select_1 = { .MGAIN20 = 0b110, .PMMP = 0, .MPSEL = 0, .DACS = 0, .MGAIN3 = 0, .SLPSN = 0, }, .signal_select_2 = { .INR = 0b00, .INL = 0b00, .MICL = 0, .reserved0 = 0, .SPKG = 0b00, }, .signal_select_3 = { .MONO = 0b00, .PTS = 0b01, .reserved0 = 0, .DACL = 0, .LVCM = 0b01, }, .mode_control_1 = { .DIF = 0b10, .CKOFF = 0, .BCKO = 0, .PLL = 0b0101, }, .mode_control_2 = { .FS = 0b1011, .reserved0 = 0, .CM = 0b00, }, .mode_control_3 = { .reserved0 = 0, .IVOLC = 1, .reserved1 = 0, .DVOLC = 1, .SMUTE = 0, .THDET = 0, .TSDSEL = 0, }, .digital_mic = { .DMIC = 0, .DCLKP = 0, .reserved0 = 0, .DCLKE = 0, .PMDML = 0, .PMDMR = 1, .reserved1 = 0, .READ = 0, }, .timer_select = { .DVTM = 0, .MOFF = 0, .reserved0 = 0, .FRN = 0, .FRATT = 0, .ADRST = 0b00, }, .alc_timer_select = { .RFST = 0b00, .WTM = 0b00, .EQFC = 0b10, .IVTM = 1, .reserved0 = 0, }, .alc_mode_control_1 = { .LMTH10 = 0b00, .RGAIN = 0b000, .ALC = 0, .LMTH2 = 0, .ALCEQN = 0, }, .alc_mode_control_2 = { .REF = 0xe1, }, .l_ch_input_volume_control = { .IV = 0xe1, }, .r_ch_input_volume_control = { .IV = 0xe1, }, .alc_volume = { .VOL = 0x00, // Read-only. }, ._reserved_0x10 = 0x80, .r_ch_mic_gain_setting = { .MGR = 0x80, }, .beep_control = { .BPLVL = 0b0000, .BEEPH = 0, .BEEPS = 0, .BPVCM = 0, .HPZ = 0, }, .l_ch_digital_volume_control = { .DV = 0x18, }, .r_ch_digital_volume_control = { .DV = 0x18, }, .eq_common_gain_select = { .reserved0 = 0, .EQC2 = 0, .EQC3 = 0, .EQC4 = 0, .EQC5 = 0, .reserved1 = 0, }, .eq2_common_gain_setting = { .EQnT = 0b00, .EQnG = 0b000000, }, .eq3_common_gain_setting = { .EQnT = 0b00, .EQnG = 0b000000, }, .eq4_common_gain_setting = { .EQnT = 0b00, .EQnG = 0b000000, }, .eq5_common_gain_setting = { .EQnT = 0b00, .EQnG = 0b000000, }, .auto_hpf_control = { .STG = 0b00, .SENC = 0b011, .AHPF = 0, .reserved0 = 0, }, .digital_filter_select_1 = { .HPFAD = 1, .HPFC = 0b00, .reserved0 = 0, }, .digital_filter_select_2 = { .HPF = 0, .LPF = 0, .reserved0 = 0, .FIL3 = 0, .EQ0 = 0, .GN = 0b00, }, .digital_filter_mode = { .PFSDO = 1, .ADCPF = 1, .PFDAC = 0b00, .PFVOL = 0b00, .reserved0 = 0, }, .hpf_2_coefficient_0 = { .l = 0xb0 }, .hpf_2_coefficient_1 = { .h = 0x1f, .reserved0 = 0 }, .hpf_2_coefficient_2 = { .l = 0x9f }, .hpf_2_coefficient_3 = { .h = 0x20, .reserved0 = 0 }, .lpf_coefficient_0 = { .l = 0x00 }, .lpf_coefficient_1 = { .h = 0x00, .reserved0 = 0 }, .lpf_coefficient_2 = { .l = 0x00 }, .lpf_coefficient_3 = { .h = 0x00, .reserved0 = 0 }, .fil_3_coefficient_0 = { .l = 0x00 }, .fil_3_coefficient_1 = { .h = 0x00, .reserved0 = 0, .s = 0 }, .fil_3_coefficient_2 = { .l = 0x00 }, .fil_3_coefficient_3 = { .h = 0x00, .reserved0 = 0 }, .eq_coefficient_0 = { .l = 0x00 }, .eq_coefficient_1 = { .h = 0x00 }, .eq_coefficient_2 = { .l = 0x00 }, .eq_coefficient_3 = { .h = 0x00, .reserved0 = 0 }, .eq_coefficient_4 = { .l = 0x00 }, .eq_coefficient_5 = { .h = 0x00 }, .digital_filter_select_3 = { .EQ1 = 0, .EQ2 = 0, .EQ3 = 0, .EQ4 = 0, .EQ5 = 0, .reserved0 = 0, }, .device_information = { .DVN = 0b0001, .REV = 0b1100, }, .e1_coefficient_0 = { .l = 0x00 }, .e1_coefficient_1 = { .h = 0x00 }, .e1_coefficient_2 = { .l = 0x00 }, .e1_coefficient_3 = { .h = 0x00 }, .e1_coefficient_4 = { .l = 0x00 }, .e1_coefficient_5 = { .h = 0x00 }, .e2_coefficient_0 = { .l = 0x00 }, .e2_coefficient_1 = { .h = 0x00 }, .e2_coefficient_2 = { .l = 0x00 }, .e2_coefficient_3 = { .h = 0x00 }, .e2_coefficient_4 = { .l = 0x00 }, .e2_coefficient_5 = { .h = 0x00 }, .e3_coefficient_0 = { .l = 0x00 }, .e3_coefficient_1 = { .h = 0x00 }, .e3_coefficient_2 = { .l = 0x00 }, .e3_coefficient_3 = { .h = 0x00 }, .e3_coefficient_4 = { .l = 0x00 }, .e3_coefficient_5 = { .h = 0x00 }, .e4_coefficient_0 = { .l = 0x00 }, .e4_coefficient_1 = { .h = 0x00 }, .e4_coefficient_2 = { .l = 0x00 }, .e4_coefficient_3 = { .h = 0x00 }, .e4_coefficient_4 = { .l = 0x00 }, .e4_coefficient_5 = { .h = 0x00 }, .e5_coefficient_0 = { .l = 0x00 }, .e5_coefficient_1 = { .h = 0x00 }, .e5_coefficient_2 = { .l = 0x00 }, .e5_coefficient_3 = { .h = 0x00 }, .e5_coefficient_4 = { .l = 0x00 }, .e5_coefficient_5 = { .h = 0x00 }, } }; class AK4951 : public audio::Codec { public: constexpr AK4951( I2C& bus, const I2C::address_t bus_address ) : bus(bus), bus_address(bus_address) { } std::string name() const override { return "AK4951"; } bool detected(); void init() override; bool reset() override; volume_range_t headphone_gain_range() const override { return { -89.5_dB, 12.0_dB }; } void headphone_enable() override; void headphone_disable() override; void speaker_enable(); void speaker_disable(); void set_headphone_volume(const volume_t volume) override; void headphone_mute(); void microphone_enable(); void microphone_disable(); size_t reg_count() const override { return asahi_kasei::ak4951::reg_count; } size_t reg_bits() const override { return 8; } uint32_t reg_read(const size_t reg_address) override { return read(reg_address); } private: I2C& bus; const I2C::address_t bus_address; RegisterMap map { default_after_reset }; enum class LineOutSelect { Speaker, Line, }; void configure_digital_interface_i2s(); void configure_digital_interface_external_slave(); void configure_digital_interface_external_master(); void set_digtal_volume_control(const reg_t value); void set_dac_power(const bool enable); void set_headphone_power(const bool enable); void set_speaker_power(const bool enable); void select_line_out(const LineOutSelect value); reg_t read(const address_t reg_address); void update(const Register reg); void write(const address_t reg_address, const reg_t value); }; } /* namespace ak4951 */ } /* namespace asahi_kasei */ #endif/*__AK4951_H__*/